.IIF NDF L$$CDA .TITLE CRASH .IIF DF DL$$CD .TITLE DLCRSH .IIF DF DU$$CD .TITLE DUCRSH .IIF DF MS$$CD .TITLE MSCRSH .IIF DF MU$$CD .TITLE MUCRSH .IIF DF MM$$CD .TITLE MMCRSH .IIF DF NT$$CD .TITLE NTCRSH .IDENT /06.11/ ; ; Copyright (c) 1995-1999 by Mentec Inc., U.S.A. ; All rights reserved. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED ; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE. ; ; ; P. J. BEZEREDI 24-OCT-77 ; ; MODIFIED FOR RSX-11M-PLUS V2.0 BY: ; ; P. J. BEZEREDI ; B. S. MCCARTHY ; R. T. PERRON ; C. SESTOKAS ; ; MODIFIED FOR RSX-11M-PLUS V2.1 BY: ; ; P. J. BEZEREDI ; T. LEKAS ; B. S. MCCARTHY ; J. M. LAWLER ; C. SESTOKAS ; S. M. THOMAS ; ; MODIFIED FOR RSX-11M-PLUS VERSION 3.0 BY: ; ; J. W. BERZLE ; G. N. LARSEN ; J. M. LAWLER ; B. S. MCCARTHY ; M. PETTENGILL ; C. SESTOKAS ; J. G. WEHNER ; P. K. M. WEISS ; ; MODIFIED FOR RSX-11M-PLUS V4.0 BY: ; ; C. SESTOKAS ; K. L. NOEL ; ; MODIFIED FOR RSX-11M-PLUS V4.1 BY: ; ; J. W. BERZLE ; ; MODIFIED FOR RSX-11M-PLUS V4.2 BY: ; ; A. V. HUDED ; ; MODIFIED FOR RSX-11M-PLUS V4.3 - VAX COPROCESSOR/RSX V2.0 BY: ; ; K. L. NOEL ; ; MODIFIED FOR RSX-11M-PLUS V4.4 BY: ; ; D. Carroll ; ; MODIFIED FOR RSX-11M-PLUS V4.5 BY: ; ; D. Carroll 13-May-1993 06.10 ; DC210 -- Include support for crash I/O page image ; and allow UMR Map to be 0s on QBUS systems ; ; MODIFIED FOR RSX-11M-PLUS V4.6 BY: ; ; D. Carroll 18-Oct-1995 06.11 ; DC404 - Set up PSECT definitions to extend ICB pool ; ; ; CRASH DUMP ROUTINES ; ; ; MACRO LIBRARY CALLS ; .MCALL HWDDF$,BTJMP$,UDADF$,BGCK$A .MCALL CPRDF$ UDADF$ HWDDF$ CPRDF$ ; ; LOCAL MACROS ; .MACRO PUSH ARG CLR -(SP) MOV ARG,(SP) .ENDM PUSH .IF NDF,L$$CDA ;DC404 .IIF DF,K$$DAS&I$$CBP, .PSECT EXEC1 ;DC404 .ENDC ;DC404 ; ; C$$CDA = 0 LOADABLE CRASH DRIVER SUPPORT ; C$$CDA = N RESIDENT CRASH DRIVER SUPPORT ; ; WHEN RESIDENT CRASH DRIVER SUPPORT IS SELECTED, THIS MODULE WILL ; INCLUDE THE EXECUTIVE CRASH CODE ALONG WITH A SPECIFIC DRIVER. ; ; WHEN LOADABLE CRASH DRIVER SUPPORT IS SELECTED, THIS MODULE WILL ; ONLY INCLUDE THE EXECUTIVE CRASH CODE. THIS MODULE IS ASSEMBLED ; ONCE FOR EACH LOADABLE CRASH DRIVER AFTER THE EXECUTIVE IS ; ASSEMBLED. WHEN THIS MODULE IS BEING ASSEMBLED FOR A CRASH ; DRIVER THE FOLLOWING CONDITIONALS ARE DEFINED IN A PREFIX ; FILE: ; C$$CDA=0 LOADABLE CRASH DRIVER SUPPORT ; L$$CDA=0 LOADABLE CRASH DRIVERS TO BE ASSEMBLED ; XX$$CD=0 XX CRASH DRIVER SELECTED .IF DF C$$CDA .IIF GT,C$$CDA R$CRSH = 0 .ENDC .IF DF, L$$CDA ;IF ASSEMBLING CRASH DRIVER .NLIST CND ;DON'T LIST EXEC CRASH MODULE .IFF ; DF L$$CDA .PAGE .IF DF C$$CDA ;+ ; **-$CRASH-SYSTEM CRASH DUMP ROUTINE ; **-$PANIC-SYSTEM CRASH DUMP ROUTINE (REF. ENTRY ONLY) ; ; THIS ROUTINE IS ENTERED VIA A JUMP WHENEVER A FATAL SYSTEM ERROR ; (IOT) IS DETECTED. ; ; THIS ROUTINE PERFORMS A MEMORY DUMP THAT CAN BE DIRECTED TO A ; DISK OR TAPE. ONCE THE DUMP IS FINISHED THE SYSTEM MAY BE ; RE-BOOTED OR ANOTHER DUMP MAY BE TAKEN. ; IF ENTRY IS AT $CRALT, IT IS ASSUMED THAT THE MEMORY MANAGEMENT ; REGISTERS ARE PROPERLY SET UP. ; ; INPUTS: ; ; KERNEL STACK ; ; OUTPUTS: ; ; A CORE IMAGE OF THE SYSTEM IS DUMPED ONTO THE DUMP DEVICE. ;- ;+ ;**-$TRINT-GENERAL TRAP INTERCEPTION ROUTINE ; ; THIS ENTRY POINT ADDRESS MAY BE PLACED IN ANY VECTOR TO ALLOW THE ; SETTING OF THE C BIT AND AN RTI EXECUTED. ;- $TRINT:: ;REFERENCE LABEL TRP04: BIS #1,2(SP) ;SET CARRY ON TRAPS THROUGH 4 RTI ;RETURN .IFTF ;C$$CDA .IF DF M$$PRO ; ; NOTE: THIS CODE ONLY WORKS PROPERLY FOR UP TO 4 PROCESSORS. ; MODIFICATIONS WILL HAVE TO BE MADE TO HANDLE THE ; DEC HARDWARE ALPHABET. ; $CRAL1::MOV #$STACK-4,SP ;POINT TO PS PC PAIR MOV #$CRMS5,R1 ;GET ADDRESS OF MESSAGE TO BE TYPED MOV R4,R3 ;COPY PROCESSOR BIT MASK BR WRMSG ; $CRAL2::ADD #6,SP ;CLEAN THE STACK MOV #$CRMS4,R1 ;GET ADDRESS OF MESSAGE TO BE TYPED MOV R5,R3 ;COPY PROCESSOR MASK WRMSG: CALL $DISAN ;DISABLE SANITY TIMERS (ALL OF THEM) CLR R0 ;INITIALIZE PROCESSOR NUMBER 10$: CLC ;CLEAR CARRY FOR ROTATE ROR R3 ;ROTATE R3 RIGHT ONE BIT BCS 30$ ;IF CS TYPE MESSAGE BEQ 50$ ;IF EQ DONE BR 40$ ;INCREMENT PROCESSOR NUMBER AND GO AGAIN 30$: MOV R0,R2 ;CALCULATE CPU LETTER ADD #'A,R2 ; MOVB R2,$CRCPU ; MOV R1,-(SP) ;SAVE ADDRESS OF MESSAGE CALL TYPE ;TYPE MESSAGE MOV #$CRCPU,R1 ;GET ADDRESS OF CPU LETTER CALL TYPE ;TYPE PROCESSOR LETTER MOV (SP)+,R1 ;RESTORE ADDRESS OF MESSAGE 40$: INC R0 ;ADVANCE PROCESSOR NUMBER BR 10$ ;GO AGAIN 50$: ;REFERNCE LABEL .IF DF D$$DXD CLR $DXDRL ;INDICATE DON'T JMP TO DXD .ENDC ; DF D$$DXD BR $CRASH ;GO DO THE CRASH .ENDC ;M$$PRO .PAGE ; ; THIS ROUTINE IS ENTERED FROM THE DIRECTIVE DISPATCHER IF AN EMT ; IS DONE AT SYSTEM STATE. THE PC PRIOR TO THE TRAP IS SAVED. ; ; IF WE GOT HERE DUE TO A BUGCHECK (EMT 374 OR 375) AND IF ; THE FACILITY ERROR CODE AT $BCFAC IS ZERO THEN THE NEXT TWO WORDS ; IN THE I-STREAM AFTER THE EMT INSTRUCTION ARE THE FACILITY AND ERROR ; CODES. THESE CODES WILL BE STORED AND A CRASH WILL BE DONE. ; THIS ROUTINE IS ALSO CALLED WHEN AN IOT HAS OCCURED IN SYSTEM STATE. ; THIS IS USUALLY AS A RESULT OF AN OLD STYLE CRASH. IN THIS CASE ; THE FACILITY AND ERROR CODES WILL HAVE BEEN SETTUP BY SSTSR. ; THIS IS ALSO CALLED FOR A TRAP OR NON BUGCHECK EMT IN SYSTEM STATE ; IN THIS CASE THE FACILITY AND ERROR CODES ARE FILLED IN AND A ; CRASH IS DONE. ; $CREMT::MOV (SP),$BCPC ;SAVE THE PRE-CRASH PC TST $BCFAC ;HAVE THE CODES BEEN SAVED ALREADY? BNE $CRENT ;NE YES - GO CRASH MOV (SP),-(SP) ;DUPLICATE PC ON THE STACK SUB #2,(SP) ;POINT AT THE TRAP/EMT INSTRUCTION MFPI @(SP) ;GET THE INSTRUCTION BIC #1,(SP) ;GET READY FOR THE TEST CMP (PC)+,(SP) ;IS THIS EMT 374/375 (BUGCHECK)? EMT 374 BEQ 20$ ;IF EQ YES - SAVE THE CODES BGCK$A BF.INT,BE.EMT,INTERNAL ;ASSUME EMT INSTRUCTION CMPB #&377,1(SP) ;EMT INSTRUCTION? BEQ 10$ ;IF EQ YES - GO CRASH BGCK$A BF.INT,BE.TRP,INTERNAL ;TRAP INSTRUCTION 10$: CMP (SP)+,(SP)+ ;CLEAN THE STACK BR $CRENT ;GO CRASH 20$: TST (SP)+ ;CLEAN THE STACK ADD #2,(SP) ;POINT TO THE FACILITY CODE MFPI @(SP) ;GET THE FACILITY CODE MOV (SP)+,$BCFAC ;STORE IT ADD #2,(SP) ;GET THE ERROR CODE ADDRESS MFPI @(SP)+ ;GET THE FACILITY CODE MOV (SP)+,$BCERR ;STORE IT ; .PAGE ; IF CDA SUPPORT IS INCLUDED IN THE SYSTEM THIS ENTRY WILL DO ; A CRASH DUMP. IF CDA SUPPORT IS NOT INCLUDED AND THIS IS NOT ; A P/OS SYSTEM A HALT WILL BE DONE. IF THERE IS NO CDA SUPPORT ; AND THIS IS A P/OS SYSTEM R0 AND R1 WILL BE SETTUP AND A JUMP ; INTO THE BOOT ROM WILL BE DONE TO DISPLAY THE FACILITY AND ERROR ; CODES. ; $CRENT:: $PANIC:: ;REFERENCE LABEL $CRASH:: .IFF ;C$$CDA .IF DF R$$PRO MOV $BCFAC,R0 ;GET THE FACILITY CODE MOV $BCERR,R1 ;GET THE ERROR CODE BTJMP$ ;HAVE THE ROM SHOW THE MESSAGE .IFF ;R$$PRO 60$: HALT ;WE DON'T HAVE CRASH SO HALT BR 60$ ;OH NO YOU DON'T! .ENDC ;R$$PRO .IFT ;C$$CDA MOV #TRP04,@#4 ;SET UP TO SET CARRY ON TRAPS THROUGH 4 .IF DF M$$PRO BIS #4,SR3 ;ENABLE KERNEL DATA SPACE BIS #1,SR0 ;TURN ON MEMORY MANAGEMENT ;THIS TRANSFERS CONTROL TO THE ;CRASH ROUTINE IN THE PRIVATE MEMORY ;FOR THIS PROCESSOR .ENDC MOV (SP)+,$CRUPC ;SAVE USER PC FROM THE STACK MOV (SP)+,$CRUST ;SAVE USER PS FROM THE STACK $CRALT:: ;ALTERNATE ENTRY POINT USED BY 'X' COMMAND TO XDT .IF DF M$$PRO CALL $DISAN ;DISABLE SANITY TIMERS (ALL OF THEM) .ENDC .IF DF D$$DXD MOV KINAR5,$DXDK5 ;SAVE APR 5 FOR DXD MOV $DXDRL,KINAR5 ;MAP TO DXD BEQ CRSH ;IF EQ DXD NOT INSTALLED JMP @$DXDEP ;JUMP TO DXD ENTRY POINT $DXDRT::MOV $DXDK5,KINAR5 ;RESTORE KERNEL APR5 RTT ;RETURN FROM WHENCE WE CAME CRSH: MOV $DXDK5,KINAR5 ;RESTORE MAPPING FOR THE CRASH .ENDC ; DF D$$DXD MOV #TRP04,@#4 ;SET UP TO SET CARRY ON TRAPS THROUGH 4 .IF DF M$$PRO CACHE$ BYPASS ;BYPASS THE CACHE .ENDC .PAGE ; DUMP ALL VOLATILE PROCESSOR REGISTERS TO CRASH STACK ($CRSST) TSTB $CRDMP ;HAVE REGISTERS ALREADY BEEN DUMPED? BEQ 5$ ;NO IF EQ JMP 70$ ; 5$: MOV PS,$CRSST ;STORE FULL PS MOV #PMODE!PR7,PS ;LOCK OUT INTERRUPTS, PREVIOUS MODE USER MOV SP,$CRSST-2 ;;;SAVE SP MOV $CRUPC,$CRSST-4 ;;;SAVE PC BEFORE IOT CRASH MOV $CRUST,$CRSST-6 ;;;SAVE PS BEFORE IOT CRASH MOV #$CRSST-6,SP ;;;RESET SP TO INTERNAL STACK MFPI SP ;;;SAVE USER'S SP .IF DF S$$LIB MOV #PSMODE!PR7,PS ;;;SET PREVIOUS MODE TO SUPER .ENDC MFPI SP ;;;GET SUPER SP PUSH CPUERR ;;;SAVE CPU ERROR REGISTER NOP ;;;THIS INSTRUCTION MUST BE HERE FOR ;;;THE 11/60. UNLESS THE APPROPRIATE ;;;ECO HAS BEEN APPLIED, ACCESSING ;;;THE CPU ERROR REGISTER WILL ;;;CAUSE THE NEXT INSTRUCTION ;;;TO BE SKIPPED PUSH MEMERR ;;;SAVE MEMORY SYSTEM ERROR REGISTER PUSH MEMCTL ;;;SAVE MEMORY CONTROL REGISTER MOV R0,-(SP) ;;;SAVE REGISTER SET 1 MOV R1,-(SP) ;;; MOV R2,-(SP) ;;; MOV R3,-(SP) ;;; MOV R4,-(SP) ;;; MOV R5,-(SP) ;;; PUSH SR0 ;;;SAVE MEMORY MANAGEMENT REGISTERS PUSH SR0+2 ;;; PUSH SR0+4 ;;; PUSH SR3 ;;; BIC #40,SR3 ;;;DISABLE UNIBUS MAP MOV #UINDR0,R0 ;;;SETUP TO SAVE FIRST SET OF APRS MOV #32.,R1 ;;; 10$: PUSH (R0) ;;;SAVE APR ADD #2,R0 ;;;MOVE TO NEXT ONE SOB R1,10$ ;;;LOOP UNTIL ALL ARE SAVED MOV #SISDR0,R0 ;;;SETUP TO SAVE SECOND SET OF APR'S MOV #64.,R1 ;;; 20$: PUSH (R0) ;;;SAVE APR ADD #2,R0 ;;;MOVE TO NEXT ONE SOB R1,20$ ;;;LOOP UNTIL ALL ARE SAVED MOV #UBMPR,R0 ;;;GET ADDRESS OF FIRST UMR MOV #62.,R1 ;;;NUMBER OF UMR'S TO SAVE 30$: PUSH (R0) ;;;SAVE A UMR ADD #2,R0 ;;;MOVE TO NEXT ONE SOB R1,30$ ;;;LOOP UNTIL ALL ARE SAVED INCB $CRDMP ;;;PROCESSOR REGISTERS HAVE BEEN SAVED .PAGE ; ; AT THIS POINT, THE FORMAT OF THE CRASH STACK (STARTING ; FROM THE BOTTOM, IS AS FOLLOWS: ; ; OFFSET REGISTER NAME ADDRESS ; ------ ------------- ------- ; ; - - - - - - UNIBUS MAPPING REGISTERS - - - - - - ; ; $CRSST-540 UNIBUS MAP REGISTER 31 (HIGH HALF) 170366 ; $CRSST-536 UNIBUS MAP REGISTER 31 (LOW HALF) 170364 ; ... ... ; $CRSST-350 UNIBUS MAP REGISTER 1 (HIGH HALF) 170202 ; $CRSST-346 UNIBUS MAP REGISTER 1 (LOW HALF) 170200 ; ; - - - - - - MEMORY MANAGEMENT REGISTERS - - - - - - ; ; $CRSST-344 KERNEL DATA SPACE ADDRESS REG. 7 172376 ; ... ... ; $CRSST-326 KERNEL DATA SPACE ADDRESS REG. 0 172360 ; $CRSST-324 KERNEL INST SPACE ADDRESS REG. 7 172356 ; ... ... ; $CRSST-306 KERNEL INST SPACE ADDRESS REG. 0 172340 ; $CRSST-304 KERNEL DATA SPACE DESCRIPTOR REG. 7 172336 ; ... ... ; $CRSST-266 KERNEL DATA SPACE DESCRIPTOR REG. 0 172320 ; $CRSST-264 KERNEL INST SPACE DESCRIPTOR REG. 7 172316 ; ... ... ; $CRSST-246 KERNEL INST SPACE DESCRIPTOR REG. 0 172300 ; $CRSST-244 SUPER DATA SPACE ADDRESS REG. 7 172276 ; ... ... ; $CRSST-226 SUPER DATA SPACE ADDRESS REG. 0 172260 ; $CRSST-224 SUPER INST SPACE ADDRESS REG. 7 172256 ; ... ... ; $CRSST-206 SUPER INST SPACE ADDRESS REG. 0 172240 ; $CRSST-204 SUPER DATA SPACE DESCRIPTOR REG. 7 172236 ; ... ... ; $CRSST-166 SUPER DATA SPACE DESCRIPTOR REG. 0 172220 ; $CRSST-164 SUPER INST SPACE DESCRIPTOR REG. 7 172216 ; ... ... ; $CRSST-146 SUPER INST SPACE DESCRIPTOR REG. 0 172200 ; $CRSST-144 USER DATA SPACE ADDRESS REG. 7 177676 ; ... ... ; $CRSST-126 USER DATA SPACE ADDRESS REG. 0 177660 ; $CRSST-124 USER INST SPACE ADDRESS REG. 7 177656 ; ... ... ; $CRSST-106 USER INST SPACE ADDRESS REG. 0 177640 ; $CRSST-104 USER DATA SPACE DESCRIPTOR REG. 7 177636 ; ... ... ; $CRSST-066 USER DATA SPACE DESCRIPTOR REG. 0 177620 ; $CRSST-064 USER INST SPACE DESCRIPTOR REG. 7 177616 ; ... ... ; $CRSST-046 USER INST SPACE DESCRIPTOR REG. 0 177600 .PAGE ; OFFSET REGISTER NAME ADDRESS ; ------ ------------- ------- ; ; - - - - - - MEMORY MANAGEMENT CONTROL REGISTERS - - - - - - ; ; $CRSST-044 SR3 (MMR3) 172516 ; $CRSST-042 SR2 (MMR2) 177576 ; $CRSST-040 SR1 (MMR1) 177574 ; $CRSST-036 SR0 (MMR0) 177572 ; ; - - - - - - USERS GENERAL REGISTERS - - - - - - ; ; $CRSST-034 USER R5 ; ... ... ; $CRSST-022 USER R0 ; ; - - - - - - MEMORY CONTROL/ERROR REGISTERS - - - - - - ; ; $CRSST-020 MEMORY CONTROL REGISTER 177746 ; $CRSST-016 MEMORY SYSTEM ERROR REGISTER 177744 ; $CRSST-014 CPU ERROR REGISTER 177766 ; ; - - - - - - STACK POINTERS, CRASH CONTEXT - - - - - - ; ; $CRSST-012 SUPERVISOR STACK POINTER ; $CRSST-010 USER STACK POINTER ; $CRSST-006 PS PRIOR TO CRASH ; $CRSST-004 PC PRIOR TO CRASH ; $CRSST-002 SP AT TIME OF CRASH ; $CRSST PS AFTER CRASH .PAGE ; SET UP SYSTEM TO PERFORM CRASH DUMP .IF DF M$$PRO MOVB $PROC2,R0 ;;;GET PROCESSOR NUMBER * 2 .IFF CLR R0 ;;;USE PROC 0 ON SINGLE PROCESSOR SYSTEM .IFTF INC $CRFLG(R0) ;;;INDICATE (TO OTHER PROCESSORS) THAT ;;;THIS PROCESSOR HAS DUMPED ITS REGS .IFF .IF DF K$$DAS BIS #4,SR3 ;;;ENABLE KERNEL DATA SPACE .ENDC BIS #1,SR0 ;;;MAKE SURE MEM MGMT IS ON .IFT TSTB $CRFPR ;;;IS THIS THE FIRST PROCESSOR TO CRASH? BGE 31$ ;;;IF GE NO MOVB $PROCN,$CRFPR ;;;SAVE ID OF PROCESSOR .IF NE M$$PRO-1 MOV $URMST,R1 ;;;DETERMINE ONLINE PROCESSORS BIC $CPMSK,R1 ;;; BIC $CPBIT,R1 ;;;EXCLUDE THIS PROCESSOR MOV #MP.CRH,R2 ;;;GET CRASH FUNCTION CODE CALL $IIFNX ;;;NOTIFY OTHER PROCESSORS TO CRASH CACHE$ BYPASS ;;;SET THE CACHE BYPASS BIT AGAIN .IFTF 31$: CALL $IIOPN ;;;OPEN UP THE IIST .IFT .ENDC ; NE M$$PRO-1 .IFTF ; DF M$$PRO ;+ ; IF WE HAVE AN I/O PAGE REGION, MAKE A COPY OF THE CURRENT I/O ; PAGE ... ;- MOV $CRIOP,R0 ;;; GET I/O PAGE REGION PCB BEQ 314$ ;;; IF EQ, NO PCB TO USE BIT #P2.LMA,P.ST2(R0) ;;; IS THIS REALLY OURS? BEQ 314$ ;;; IF EQ NOPE ... MOV @#KISAR6,-(SP) ;;; SAVE THE CONTENTS FOR A MOMENT MOV P.REL(R0),@#KISAR6 ;;; MAP TO THE REGION VIA PAR6 MOV #77406,@#KISDR6 ;;; AND 4.KW R/W ACCESS .IFT ;DF M$$PRO MOVB $PROCN,R0 ;;; GET THE PROCESSOR INDEX SWAB R0 ;;; MULTIPLY BY 256 ASR R0 ;;; AND DOWN TO 4.KW/CPU ADD R0,@#KISAR6 ;;; AND ADJUST TO CORRECT REGION .IFTF ;DF M$$PRO BIS #60,@#SR3 ;;; INSURE 22-BIT ADDRESSING IS ON ... CLR R0 ;;; START AT ABSOLUTE 0 MOV #160000,R1 ;;; AND THE TOP OF APR6 312$: MOV #-1,-(R1) ;;; INITIALIZE TO NXM INFO MOV -(R0),(R1) ;;; AND COPY A WORD CMP R0,#160000 ;;; ARE WE DONE BNE 312$ ;;; IF NE, KEEP ON GOING ... MOV (SP)+,@#KISAR6 ;;; RESTORE KERNEL APR6 MAPPING 314$: ;;; REFERENCE LABEL ; ; IF WE'RE HERE DUE TO A BUGCHECK, OUTPUT THE BUGCHECK MESSAGE ; .IF NDF, C$$NCO ;;; NO LOCAL CONSOLE TST $BCFAC ;;;BUGCHECK FACILITY SET ? BEQ 315$ ;;;IF EQ NO MOV #$BCMSG,R0 ;;;POINT TO FIRST MESSAGE MOV $BCPC,R3 ;;;GET PC OF BUGCHECK CALL OCTSTR ;;;OUTPUT MESSAGE MOV $BCFAC,R3 ;;;GET FACILITY OF BUGCHECK CALL OCTSTR ;;;OUTPUT MESSAGE MOV $BCERR,R3 ;;;GET ERROR CODE OF BUGCHECK CALL OCTSTR ;;;OUTPUT MESSAGE CALL TYPE ;;;OUTPUT TRAILER 315$: ;;;REFERENCE LABEL .ENDC ; C$$NCO .IFT ; DF M$$PRO .IF NE M$$PRO-1 MOV #$CRMS2,R1 ;;;INDICATE REGS HAVE BEEN SAVED CALL TYPE ;;;TYPE THE MESSAGE MOV $CRKRB,R1 ;;;GET CRASH DEVICE KRB ADDRESS BEQ 35$ ;;;IF EQ ASSUME PROCESSOR HAS ACCESS BIT K.URM(R1),@$CPURM ;;;DOES THIS PROC HAVE ACCESS TO DISK? BNE 35$ ;;;YES IF NE 32$: JMP $CRSHT ;;;HALT 35$: ASRB $CRLCK ;;;LOCK THE CRASH LOCK BCC 32$ ;;;HALT IF LOCK IS LOCKED MOV #$CRMS1,R1 ;;;PROC IS WAITING FOR OTHERS TO FINISH CALL TYPE ;;;TYPE THE MESSAGE 40$: MOV #,R0 ;;;GET NUMBER OF PROCESSORS 50$: BIT $BTMSK(R0),$URMST ;;;IS THIS PROCESSOR ONLINE? BEQ 55$ ;;;NO IF EQ TST $CRFLG(R0) ;;;HAS PROCESSOR DUMPED ITS REGISTERS? BEQ 40$ ;;;IF EQ NO, WAIT FOR ALL PROCS TO DUMP 55$: SUB #2,R0 ;;;CHECK NEXT PROCESSOR BGE 50$ ;;;GO AGAIN .ENDC .ENDC 70$: MOV #PR7,PS ;;;MAKE SURE WE'RE AT PRIORITY 7 .IF EQ, C$$CDA ;LOADABLE CRASH DRIVER SUPPORT BIS #60,@#SR3 ;;; TURN ON MEMORY MANAGEMENT MOV @#$CRPAR,@#KINAR5 ;;; RELATIVE ADDRESS OF CRASH PAR .IF DF K$$DAS MOV @#$CRPAR,@#KDSAR5 ;;; MAP D SPACE ALSO .ENDC ;DF K$$DAS BNE 80$ ;;; CRASH DRIVER IS LOADED MOV #$CRMS7,R1 ;;; MOVE IN THE MESSAGE CALL TYPE ;;; TYPE IT OUT 75$: HALT ;;; AND STOP BR 75$ ;;; STOP ! 80$: JMP @120000 ;;; JMP TO CRASH PARTITION .ENDC ; EQ, C$$CDA .ENDC ; DF C$$CDA .ENDC ; DF L$$CDA .IF DF, C$$CDA ;CRASH DUMP SUPPORT .IF EQ C$$CDA-20 ; CRASH THROUGH KXJ PBNH== 0 ; SET UP TO IGNORE THIS IN LOWCR PBNL== 0 MOV $CSFSV,@#KXCSRF ;;; SET ALL OF MEMORY SHARED MOV $CSHSV,@#KXCSRH ;;; ... MOV $KXPTR,R0 ;;; GET ADDRESS OF KXJ DRIVER'S DCB MOV D.UCB(R0),R0 ;;; GET ADDRESS OF UCB MOV U.SCB(R0),R0 ;;; GET ADDRESS OF SCB MOV S.KRB(R0),R0 ;;; GET ADDRESS OF KRB MOV K.CSR(R0),R0 ;;; GET TPR0 ADDRESS MOV #RI$CRH,4(R0) ;;; SET CRASH NOTIFICATION CODE MOV $KXVC1,R1 ;;; GET ADDRESS OF FIRST VECTOR ADD #4,R1 ;;; GET ADDRESS OF SECOND VECTOR MOV R1,@#KXJQIR ;;; NOTIFY HOST THROUGH VECTOR 2 90$: HALT ;;; HALT TO LET HOST COPY MEMORY BR 90$ ;;; DON'T CONTINUE .IFF ; EQ C$$CDA-20 ; THE FOLLOWING CODE SHOULD BE ASSEMBLED INTO EXECUTIVE WHEN ; RESIDENT CRASH DUMP DRIVER SUPPORT IS INCLUDED. IT SHOULD ; BE INCLUDED IN THE CRASH DRIVER WHEN LOADABLE CRASH SUPPORT ; IS SELECTED. .IF DF, L$$CDA!R$CRSH ;RESIDENT CRASH OR CRASH DRIVER ; ; TYPE MESSAGE AND WAIT FOR USER ; AGAIN: .IF NDF, C$$NCO ;;; NO LOCAL CONSOLE .IF DF, L$$CDA MOV CRMS0,R1 ;;; TYPE USER MESSAGE .IFF MOV #$CRMS0,R1 ;;; USER CRASH MESSAGE .ENDC ; DF L$$CDA CALL TYPE ;;; HALT ;;; WAIT FOR THE USER .ENDC ; C$$NCO JMP DUMP ;;; GO DUMP MEMORY .IFTF ; DF L$$CDA!R$CRSH ;+ ; **-OCTSTR-OUTPUT AN ASCIZ STRING, THEN OCTAL NUMBER ; **-OCTOUT-OUTPUT OCTAL NUMBER TO CONSOLE ; ; INPUTS: ; R0=ADDRESS OF ASCIZ STRING IF OCTSTR ; (RETURNED UPDATED) ; R3=BINARY VALUE TO OUTPUT ;- OCTSTR: MOV R0,R1 ;;;COPY ADDRESS OF STRING CALL TYPE ;;;OUTPUT IT MOV R1,R0 ;;;UPDATE OUTPUT POINTER .IF DF, L$$CDA ; GL003 OCTOUT: MOV BCBUF,R1 ;;;POINT TO SCRATCH AREA ; GL003 .IFF ; DF L$$CDA ; GL003 OCTOUT: MOV #$BCBUF,R1 ;;;POINT TO SCRATCH AREA .ENDC ; DF L$$CDA ; GL003 MOV #6,R2 ;;;SET LOOP COUNTER 10$: MOV R3,R4 ;;;COPY RESIDUE BIC #177770,R4 ;;;STRIP OFF ALL BUT LAST OCT. DIGIT ADD #60,R4 ;;;MAKE IT AN ASCII CHARACTER MOVB R4,-(R1) ;;;STORE THE CHARACTER ROR R3 ;;;SHIFT RESIDUE ONE RIGHT (WE KNOW ;;;C IS CLEAR FROM THE ADD ABOVE) ASR R3 ;;;SHIFT TWO (C MAY NOT BE CLEAR, BUT ;;;NOW WE KNOW SIGN BIT IS ASR R3 ;;;SHIFT THREE SOB R2,10$ ;;;LOOP UNTIL SIX CHARACTERS ;;;FALL THROUGH TO TYPE ROUTINE WITH ;;;R1 POINTING TO SCRATCH AREA ;+ ; **-TYPE-TYPE AN ASCIZ MESSAGE ; ; INPUTS: ; R1=ADDRESS OF TEXT STRING ;- TYPE: MOV #C$$RSH,R5 ;;;GET CSR ADDRESS OF PRINT DEVICE 10$: MOVB (R1)+,R2 ;;;GET CHARACTER BEQ 40$ ;;;IF EQ END OF MESSAGE CALL 30$ ;;;PRINT CHARACTER CMPB #15,R2 ;;;CARRIAGE RETURN (OR LINE FEED) ? BLT 10$ ;;;IF LT NOT EITHER CLR R2 ;;;OUTPUT SOME FILL CHARACTERS MOV #5,R4 ;;;FIVE WILL BE ENOUGH 20$: CALL 30$ ;;;OUTPUT A FILL SOB R4,20$ ;;;LOOP UNTIL DONE BR 10$ ;;;LOOP 30$: TSTB (R5) ;;;IS DEVICE READY? BPL 30$ ;;;IF PL NO MOVB R2,2(R5) ;;;PRINT CHARACTER 40$: RETURN ;;; .IFT ; DF L$$CDA!R$CRSH ;+ ; **-CKSUM-VERIFY CHECKSUM OF DEVICE ADDRESS ; ; THIS ROUTINE WILL VERIFY THAT THE DEVICE ADDRESS ; HAS NOT BEEN CORRUPTED BY THE CRASH. ;- .IF DF, L$$CDA ; GL003 CKSUM: MOV @CRSBN,-(SP) ;;;GET HIGH ORDER BITS ; GL003 ADD @CRSB2,(SP) ;;;ADD LOW ORDER BITS ; GL003 CMP (SP)+,@CRSCS ;;;COMPARE WITH CHECKSUM; GL003 .IFF ; DF L$$CDA ; GL003 CKSUM: MOV @#$CRSBN,-(SP) ;;;GET HIGH ORDER BITS ADD @#$CRSBN+2,(SP) ;;;ADD LOW ORDER BITS CMP (SP)+,@#$CRSCS ;;;COMPARE WITH CHECKSUM .ENDC ; DF L$$CDA ; GL003 BEQ 10$ ;;;IF EQ OK HALT ;;;WAIT FOR USER BR CKSUM ;;;TRY AGAIN 10$: RETURN ;;; ;+ ; **-DUMP-DUMP THE SYSTEM IMAGE ; ; THIS ROUTINE IS USED TO DUMP THE SYSTEM IMAGE ONTO THE CRASH ; DUMP MEDIA. WHEN THE DUMP IS FINISHED THE SYSTEM MAY BE EITHER ; RE-BOOTED OR ANOTHER DUMP MAY BE TAKEN. ; ; INPUTS: ; NONE. ; ; OUTUTS: ; IMAGE DUMPED. ;- DUMP: ;;;DUMP IMAGE ONTO MEDIA .IF DF, L$$CDA ; LOADABLE CRASH DRIVER MOV @CRKRB,R0 ;;; GET DUMP DEVICE KRB ADDRESS ; GL003 BNE 5$ ;;; IF NE GET CSR FROM KRB ; GL003 MOV CRCSR,R0 ;;; GET ADDRESS OF WORD WITH CSR ADDRESS 5$: MOV (R0),R0 ;;; GET CSR OF DUMP DEVICE ; GL003 ;;; (K.CSR IS GUARANTEED TO BE 0);GL003 MOV @CRSUN,R3 ;;; GET UNIT NUMBER ; GL003 .IFF ; DF L$$CDA ; GL003 MOV @#$CRKRB,R0 ;;;GET DUMP DEVICE KRB ADDRESS BNE 5$ ;;;IF NE GET CSR FROM KRB MOV #$CRCSR,R0 ;;;GET ADDRESS OF WORD WITH CSR ADDRESS 5$: MOV (R0),R0 ;;;GET CSR OF DUMP DEVICE ;;;(K.CSR IS GUARANTEED TO BE 0) MOV @#$CRSUN,R3 ;;;GET UNIT NUMBER .ENDC ; DF L$$CDA ; GL003 DUMP1: ;;;DUMMY LABEL SO DUMP ROUTINES CAN ;;;USE ANY LOCAL LABEL THEY WANT TO ;;;USE .IFTF ; DF L$$CDA!R$CRSH .IF EQ C$$CDA-1 ; ; DT ; ; THIS ROUTINE DUMPS ALL OF PHYSICAL MEMORY UP TO A MAXIMUM OF ; 124K WORDS ; PBNH== 0 ;;;HIGH ORDER TC11 BLOCK NUMBER PBNL== 1 ;;;LOW ORDER TC11 BLOCK NUMBER CALL CKSUM ;;;CHECK BLOCK NUMBER AGAINST CHECKSUM SWAB R3 ;;;POSITION UNIT BITS MOV R3,R1 ;;;COPY BIS #4003,R1 ;;;SET FOR READ LBN IN REVERSE MOV R1,(R0) ;;;START THE TAPE 10$: BIT #100200,(R0) ;;;ERROR OR READY? BEQ 10$ ;;;IF EQ NO BPL DUMP ;;;IF PL MOVE UNTIL ENDZONE 20$: MOV R3,R1 ;;;RETRIEVE UNIT BITS BIS #3,R1 ;;;SET TO READ LBN FORWARD MOV R1,(R0) ;;;START THE TAPE 30$: BIT #100200,(R0) ;;;ERROR OR READY? BMI DUMP ;;;IF MI ERROR, RESTART BEQ 30$ ;;;IF EQ WAIT SUB @#$CRSBN+2,6(R0);;;ARE WE AT THE BLOCK WE WANT? BNE 20$ ;;;IF NE NO CLR 2(R0) ;;;SET WRITE ALL OF MEMORY (UP TO CLR 4(R0) ;;;TO 124K) IN 64K WORD SEGMENTS MOV R3,R1 ;;;RETRIEVE UNIT BITS BIS #15,R1 ;;;SET TO WRITE DATA FORWARD MOV R1,(R0) ;;;WRITE ALL MEMORY 50$: CLR 2(R0) ;;;KEEP WRITING TST (R0) ;;;ANY ERRORS? BPL 50$ ;;;IF PL NO BIT #400,-2(R0) ;;;NONEXISTENT MEMORY? BEQ WERR ;;;IF EQ NO, RETRY BIS #1,R3 ;;;SET TO STOP TAPE MOV R3,(R0) ;;;STOP TAPE BR $CRSHT ;;;SUCCESS, FINISH .ENDC .IF EQ C$$CDA-2 ; ; DK ; ; IF THE EXECUTIVE DOES NOT SUPPORT 22-BIT ADDRESSING, THIS ; ROUTINE DUMPS ALL OF PHYSICAL MEMORY UP TO A MAXIMUM OF ; 124K WORDS. ; ; IF THE EXECUTIVE SUPPORTS 22-BIT ADDRESSING, THIS ROUTINE ; DUMPS ALL OF PHYSICAL MEMORY UP A MAXIMUM OF APPROXIMATELY ; 1.2 MEGAWORDS OF MEMORY (FILLS UP THE RK05). ; PBNH== 0 ;;;HIGH ORDER RK11 DISK ADDRESS PBNL== 1 ;;;LOW ORDER RK11 DISK ADDRESS CALL CKSUM ;;;CHECK DISK ADDRESS AGAINST CHECKSUM ASH #13.,R3 ;;;POSITION UNIT BITS MOV #401,(R0) ;;;RESET RK11 CONTROLLER BIS @#$CRSBN+2,R3 ;;;SET STARTING DISK ADDRESS MOV R3,6(R0) ;;;SET DISK ADDRESS CLR @#UBMPR ;;;INITIALIZE FIRST UMR CLR @#UBMPR+2 ;;;... BIS #60,@#SR3 ;;;ENABLE 22-BIT MAPPING AND UNIBUS MAP ;;;(KERNEL D HAS BEEN CONDITIONALLY ENABLED) 40$: MOV 6(R0),R3 ;;;GET DISK ADDRESS BIC #160017,R3 ;;;EXTRACT CYLINDER AND SURFACE CMP #14420,R3 ;;;ABOUT TO WRITE CYLINDER THAT ;;;CANNOT ORDINARILY BE READ? BEQ $CRSHT ;;;IF EQ YES, STOP WRITING CLR 4(R0) ;;;INITIALIZE TRANSFER ADDRESS MOV #-6000,2(R0) ;;;WRITE 3K WORDS (1 CYLINDER) MOV #403,(R0) ;;;START THE WRITE 45$: BIT #100200,(R0) ;;;ERROR OR READY? BEQ 45$ ;;;IF EQ NO BMI 50$ ;;;IF MI ERROR ADD #14000,@#UBMPR ;;;POINT TO NEXT 3K WORD SEGMENT ADC @#UBMPR+2 ;;;... BR 40$ ;;;GO AGAIN UNTIL END OF MEMORY 50$: BIT #2000,-2(R0) ;;;NONEXISTENT MEMORY? BNE $CRSHT ;;;YES IF NE HALT .ENDC .IF EQ C$$CDA-3 ; ; MT ; ; THIS ROUTINE DUMPS ALL OF PHYSICAL MEMORY (UP TO A MAXIMUM ; OF 124K WORDS) IN 512 BYTE RECORDS AT 800 BPI (9-TRACK) ; PBNH== 0 ;;;BLOCK NUMBER IGNORED FOR TM11 PBNL== 0 ;;; SWAB R3 ;;;POSITION UNIT SELECT BITS BIS #60001,R3 ;;;MERGE DENSITY AND GO BITS MOV R3,R2 ;;;COPY BIS #16,R2 ;;;SET REWIND FUNCTION MOV R2,(R0) ;;;START THE REWIND 10$: BIT #100200,(R0) ;;;ERROR OR READY? BMI WERR ;;;IF MI ERROR, RETRY BEQ 10$ ;;;IF EQ NO CLR (R0) ;;;CLEAR MTC REGISTER CLR 4(R0) ;;;START TO WRITE ALL MEMORY MOV R3,R2 ;;;RETRIEVE MTC BITS BIS #4,R2 ;;;SET WRITE DATA FUNCTION BIC #1,R2 ;;;CLEAR GO BIT MOV R2,(R0) ;;;LOAD MTC REGISTER 30$: MOV #500,R1 ;;;WAIT FOR TAPE TO SETTLE DOWN 35$: DEC R1 ;;;WAIT BNE 35$ ;;;IF NE LOOP MOV #-512.,2(R0) ;;;SET 512. BYTE RECORDS BIS #1,(R0) ;;;START THE WRITE 40$: BIT #100200,(R0) ;;;ERROR OR READY? BEQ 40$ ;;;IF EQ NO BPL 30$ ;;;IF PL WRITE FINISHED TSTB -2(R0) ;;;NONEXISTENT MEMORY? BPL WERR ;;;IF PL NO, RETRY MOV R3,R2 ;;;RETRIEVE MTC BITS BIS #10000,R2 ;;;SET CLEAR FUNCTION MOV R2,(R0) ;;;LOAD FUNCTION 50$: TSTB (R0) ;;;READY? BPL 50$ ;;;IF PL NO BIS #6,R3 ;;;SET WRITE EOF FUNCTION MOV R3,(R0) ;;;DO THE WRITE EOF 60$: TSTB (R0) ;;;READY? BPL 60$ ;;;IF PL NO CLR (R0) ;;;CLEAR MTC REGISTER BR $CRSHT ;;;SUCCESSFUL COMPLETION .ENDC .IIF EQ C$$CDA-4 CDA$MM=0 .IF DF CDA$MM!MM$$CD ; ; MM ; ; THIS ROUTINE DUMPS ALL OF PHYSICAL MEMORY IN 512 BYTE ; RECORDS AT 800 BPI ; PBNH== 0 ;;;BLOCK NUMBER IGNORED FOR TJU16 PBNL== 0 ;;; BIS (PC)+,R3 ;;;SET MODE AND DENSITY $TDNSY::.WORD 1300 ;;;DEFAULT TO 800 BPI, NORMAL MODE .IF DF L$$CDA MOV @CRSFM,R2 ;;;RETRIEVE FORMATTER NUMBER .IFF ; DF L$$CDA MOV @#$CRSFM,R2 ;;;RETRIEVE FORMATTER NUMBER .ENDC ; DF L$$CDA CALL 120$ ;;;SELECT FORMATTER/UNIT MOV 26(R0),R4 ;;;RETRIEVE DEVICE TYPE REGISTER BIT #40000,R4 ;;;IS THIS A MASSBUS TAPE? BEQ 10$ ;;;IF EQ NO BIT #10000,10(R0) ;;;NON EXISTENT DRIVE? BNE WERR ;;;IF NE, YES. BIT #50,R4 ;;;TM02/3 FORMATTER? BNE 20$ ;;;IF NE YES .IF DF L$$CDA 10$: MOV CRMS6,R1 ;;;NO, ILLEGAL DEVICE .IFF ; DF L$$CDA 10$: MOV #$CRMS6,R1 ;;;NO, ILLEGAL DEVICE .ENDC ; DF L$$CDA BR WERR1 ;;;PRINT OUT MESSAGE AND TRY AGAIN 20$: BIT #2000,R4 ;;;IS SLAVE UNIT PRESENT? BEQ WERR ;;;IF EQ NO .IF DF L$$CDA CLR @CRBAE ;;;INITIALIZE BAE FLAG .IFF ; DF L$$CDA CLR @#$CRBAE ;;;INITIALIZE BAE FLAG .ENDC ; DF L$$CDA MOV R0,R4 ;;;;COPY CSR ADDRESS ADD #26,R4 ;;;ADD OFFSET TO DRIVE TYPE REGISTER 30$: ADD #2,R4 ;;; R4 > REGISTER (11/24 PROBLEM) TST (R4) ;;; DEVICE REGISTER THERE? BCC 30$ ;;;IF CC IT EXISTS SUB #34,R4 ;;;SUB # OF DEVICE REGISTERS + 2 SUB R0,R4 ;;; BNE 40$ ;;;IF NE IT'S AN RH70 CONTROLLER .IF DF L$$CDA COM @CRBAE ;;;IT'S NOT, RESET BAE FLAG .IFF ; DF L$$CDA COM @#$CRBAE ;;;IT'S NOT, RESET BAE FLAG .ENDC ; DF L$$CDA CLR @#UBMPR ;;;AND INITIALIZE FIRST UNIBUS ... CLR @#UBMPR+2 ;;;;... MAPPING REGISTERS 40$: BIS #60,@#SR3 ;;;ENABLE 22 BIT MAPPING AND UNIBUS MAP MOV #<4*4>,R5 ;;;NUMBER OF 512 BYTE RECORDS/4K BLOCK CALL 120$ ;;;SELECT FORMATTER/UNIT MOV #7,(R0) ;;;START THE TAPE REWINDING MOV #40000,R1 ;;;PAUSE 50$: SOB R1,50$ ;;;LOOP FOR DELAY TIME 60$: BIT #20000,12(R0) ;;;POSITIONING STILL IN PROGRESS? BNE 60$ ;;;IF NE YES TSTB 12(R0) ;;;DRIVE READY? BPL 60$ ;;;IF PL NO MOV #60,(R0) ;;;LOAD THE WRITE FUNCTION CLR 4(R0) ;;;SET TO WRITE ALL OF MEMORY 70$: MOV #-256.,2(R0) ;;;SET WORD COUNT MOV #-512.,6(R0) ;;;SET FRAME COUNT BIS #1,(R0) ;;;START TO WRITE ALL OF MEMORY 80$: TSTB 12(R0) ;;;DRIVE READY? BPL 80$ ;;;IF PL NO DEC R5 ;;;DECREMENT BLOCK COUNT BNE 100$ ;;;IF NE USE SAME UMR .IF DF L$$CDA TST @CRBAE ;;;IS THE BAE REGISTER THERE? .IFF ; DF L$$CDA TST @#$CRBAE ;;;IS THE BAE REGISTER THERE? .ENDC ; DF L$$CDA BEQ 90$ ;;;IF EQ YES ADD #<1024.*4*2>,@#UBMPR ;;;NO, POINT UMR TO NEXT 4K OF MEM ADC @#UBMPR+2 ;;;DOUBLE WORD ADD CLR 4(R0) ;;;RESET BUS ADDRESS 90$: MOV #<4*4>,R5 ;;;RESET TO # BLOCKS PER 4K 100$: BIT #40000,(R0) ;;;TRANSFER ERRORS? BEQ 70$ ;;;IF EQ NO BIT #4000,10(R0) ;;;NONEXISTENT MEMORY? BEQ WERR ;;;IF EQ NO CALL 130$ ;;;SELECT FORMATTER/UNIT MOV #27,(R0) ;;;WRITE EOF ON TAPE 110$: TSTB 12(R0) ;;;IS TAPE DRIVE READY? BPL 110$ ;;;IF PL NO CLR (R0) ;;;CLEAR CONTROLLER REGISTER BR $CRSHT ;;;SUCCESSFUL COMPLETION 120$: BIS #40,10(R0) ;;;RESET RH CONTROLLER MOV R2,10(R0) ;;;SELECT FORMATTER MOV R3,32(R0) ;;;SELECT UNIT 130$: TSTB 12(R0) ;;;IS THE TAPE DRIVE READY? BPL 130$ ;;;IF PL NO RETURN ;;;EXIT .ENDC ; DF CDA$$MM!MM$$CD .IIF EQ C$$CDA-5 CDA$DB=0 ;;; .IIF EQ C$$CDA-11 CDA$DR=0 ;;; .IF DF CDA$DB!CDA$DR ; ; DB AND DR ; ; THE LOCAL SYMBOLS REFERENCED ABOVE, CDA$DB AND CDA$DR, ARE ; USED WITHING THE FOLLOWING COMMON CODE DRIVER BELOW TO ; DIFFERENTIATE BETWEEN RP04/5/6 AND RM02/3/5 TYPE DRIVES. ; ; THIS ROUTINE DUMPS ALL OF PHYSICAL MEMORY ; PBNH== 0 ;;;DEFAULT CYLINDER ADDRESS PBNL== 1 ;;;DEFAULT TRACK AND SECTOR ADDRESS CALL CKSUM ;;;CHECK DISK ADDRESS AGAINST CHECKSUM MOV #40,10(R0) ;;;RESET RH CONTROLLER MOVB R3,10(R0) ;;;SELECT UNIT MOV 26(R0),R4 ;;;RETRIEVE DEVICE TYPE REGISTER BIT #40000,R4 ;;;IS THIS A MASSBUS DISK? BNE 5$ ;;;IF NE NO BIC #^C<777>,R4 ;;;CLR EXTRANEOUS BITS BIT #20,R4 ;;;IS IT A DISK OF INTEREST? BEQ 5$ ;;;IF EQ NO CMP #25,R4 ;;;IS IT RP04/5/6 OR RM02/3? BHIS 10$ ;;;IF HIS YES CMP #27,R4 ;;;IS IT RM05? BEQ 10$ ;;;IF EQ YES 5$: MOV #$CRMS6,R1 ;;;NO, ILLEGAL DEVICE BR WERR1 ;;;PRINT MESSAGE AND TRY AGAIN 10$: CLR @#$CRBAE ;;;INITIALIZE BAE FLAG MOV R0,R4 ;;;;COPY CSR ADDRESS ADD #26,R4 ;;;ADD OFFSET TO DRIVE TYPE REGISTER 20$: ADD #2,R4 ;;; R4 > register (11/24 and 11/84 problem). TST (R4) ;;; Device reg there? BCC 20$ ;;;IF CC IT EXISTS SUB #50,R4 ;;;SUB # OF DEVICE REGISTERS + 2 SUB R0,R4 ;;; BNE 30$ ;;;IF NE IT'S AN RH70 CONTROLLER COM @#$CRBAE ;;;IT'S NOT, RESET BAE FLAG CLR @#UBMPR ;;;AND INITIALIZE FIRST UNIBUS ... CLR @#UBMPR+2 ;;;;... MAPPING REGISTERS 30$: BIS #60,@#SR3 ;;;ENABLE 22 BIT MAPPING AND UNIBUS MAP MOV #40,10(R0) ;;;CLEAR CONTROLLER MOVB R3,10(R0) ;;;SELECT UNIT MOV #23,(R0) ;;;DO A PACK ACKNOWLEDGE MOV @#$CRSBN,34(R0) ;;;SELECT CYLINDER MOV @#$CRSBN+2,6(R0);;;SET SECTOR AND TRACK CLR 4(R0) ;;;ZERO BUFFER ADDRESS MOV #14000,32(R0) ;;;SET 16-BIT FORMAT 40$: MOV #-<256.*4*4>,2(R0) ;;;WORD COUNT = 4K WORDS MOVB #61,(R0) ;;;START TO WRITE ALL OF MEMORY 50$: MOV #10,-(SP) ;;; Stack - delay loop count. 51$: BIS -(SP),(SP)+ ;;; Delay for 11/84 (DR) problem. DEC (SP) ;;; End of delay? BNE 51$ ;;; IF NE, No - delay some more. TST (SP)+ ;;; Maintain stack. BIT #100200,(R0) ;;;READY OR ERROR? BEQ 50$ ;;;IF EQ NEITHER TST @#$CRBAE ;;;;IS THE BAE REGISTER THERE? BEQ 60$ ;;;IF EQ YES ADD #<1024.*4*2>,@#UBMPR ;;;NO, POINT UMR TO NEXT 4K OF MEM ADC @#UBMPR+2 ;;;DOUBLE WORD ADD CLR 4(R0) ;;;RESET BUS ADDRESS 60$: BIT #40000,(R0) ;;;TRANSFER ERROR? BEQ 40$ ;;;IF EQ NO BIT #4000,10(R0) ;;;NONEXISTENT MEMORY ERROR? BNE $CRSHT ;;;IF NE YES, ELSE I/O ERROR .ENDC .IF EQ C$$CDA-6 ; ; DM ; ; IF THE EXECUTIVE DOES NOT SUPPORT 22-BIT ADDRESSING, THIS ; ROUTINE DUMPS ALL OF PHYSICAL MEMORY UP TO A MAXIMUM OF ; 124K WORDS. ; ; IF THE EXECUTIVE SUPPORTS 22-BIT ADDRESSING, THIS ROUTINE ; DUMPS ALL OF PHYSICAL MEMORY. ; ; NOTE THAT THE STANDARD METHOD OF DUMPING ALL OF PHYSICAL ; MEMORY (DUMPING UNTIL THE CONTROLLER DETECTS NONEXISTENT ; MEMORY) DOES NOT WORK, BECAUSE THE RK611 WRITES AN UNCORRECTABLE ; ECC ERROR IN THE LAST SECTOR IT WRITES UNDER THOSE CONDITIONS. ; PBNH== 0 ;;;RK06 DEFAULT CYLINDER ADDRESS PBNL== 1 ;;;DEFAULT SECTOR AND TRACK ADDRESS MOV #TRP04,@#114 ;;;POSITION TRAP CATCHER FOR NON- ;;;EXISTENT MEMORY TRAPS WHEN ;;;SIZE REGISTER > SIZE OF MEMORY CALL CKSUM ;;;CHECK BLOCK NUMBER AGAINST CHECKSUM CLR R2 ;;;ASSUME DRIVE IS AN RK06 MOV #40,10(R0) ;;;CLEAR THE RK611 SUBSYSTEM MOV R3,10(R0) ;;;SELECT THE UNIT MOV #1,(R0) ;;;SELECT THE DRIVE FUNCTION 10$: TSTB (R0) ;;;READY? BPL 10$ ;;;IF PL NO BIT #400,12(R0) ;;;IF THIS AN RK07? BEQ 20$ ;;;IF EQ NO, IT'S AN RK06 BIS #2000,R2 ;;;SET RK07 BIT 20$: MOV #40,10(R0) ;;;CLEAR THE RK611 SUBSYSTEM MOV R3,10(R0) ;;;SELECT THE UNIT MOV R2,R1 ;;;COPY DRIVE TYPE BIT BIS #3,R1 ;;;GET PACK ACK FUNCTION CODE MOV R1,(R0) ;;;DO A PACK ACKNOWLEDGE 30$: TSTB (R0) ;;;READY? BPL 30$ ;;;IF PL NO MOV 12(R0),R1 ;;;GET DRIVE STATUS COM R1 ;;;COMPLEMENT BIT #100301,R1 ;;;DRIVE READY TO GO? BNE WERR ;;;IF NE NO, TRY AGAIN MOV @#$CRSBN,20(R0) ;;;LOAD CYLINDER MOV @#$CRSBN+2,6(R0);;;LOAD SECTOR/TRACK BIS #23,R2 ;;;SET WRITE FUNCTION CLR @#UBMPR ;;;INITIALIZE FIRST UMR CLR @#UBMPR+2 ;;;... BIS #60,@#SR3 ;;;ENABLE 22-BIT MAPPING AND UNIBUS MAP ;;;(KERNEL D HAS BEEN CONDITIONALLY ENABLED) MOV #140000,R5 ;;;SET TO MAP THROUGH APR6 CLR @#KISAR6 ;;;POINT AT FIRST BYTE OF 4K WORD MOV #77406,@#KISDR6 ;;;SEGMENT 50$: CLR 4(R0) ;;;START AT BEGINNING OF MEMORY ... ;;;... OR UNIBUS MAP MOV #-2000,2(R0) ;;;WRITE 1K WORDS PER TRANSFER BIS R2,(R0) ;;;START WRITING 60$: BIT #100200,(R0) ;;;READY OR ERROR? BEQ 60$ ;;;IF EQ NEITHER BMI WERR ;;;IF MI ERROR ADD #4000,@#UBMPR ;;;POINT TO NEXT 1K WORD BOUNDARY ADC @#UBMPR+2 ;;; ADD #40,@#KISAR6 ;;;POINT AT FIRST WORD OF NEXT ;;;TRANSFER CMP #170000,@#KISAR6 ;;;IS IT ABOVE HIGHEST POSSIBLE WORD? BEQ $CRSHT ;;;IF EQ YES TST (R5) ;;;DOES FIRST WORD OF NEXT TRANSFER ;;;EXIST? BCC 50$ ;;;IF CC YES BR $CRSHT ;;;DONE .ENDC .IIF EQ C$$CDA-7 CDA$DL=0 .IF DF CDA$DL!DL$$CD!H$$GEN ; ; DL ; ; IF THE EXECUTIVE DOES NOT SUPPORT 22-BIT ADDRESSING, THIS ROUTINE ; DUMPS ALL OF PHYSICAL MEMORY UP TO A MAXIMUM OF 124K WORDS. ; ; IF THE EXECUTIVE SUPPORTS 22-BIT ADDRESSING, THIS ROUTINE ; DUMPS ALL OF PHYSICAL MEMORY. ; ; NOTE THAT THE STANDARD METHOD OF DUMPING ALL OF PHYSICAL ; MEMORY (DUMP MEMORY UNTIL THE CONTROLLER DETECTS NONEXISTENT ; MEMORY) DOES NOT WORK ON A Q-BUS CPU WHERE SOME MEMORY IS UNUSED ; BECAUSE IT "OVERLAPS" THE I/O PAGE. FOR EXAMPLE, A 124K WORD CPU ; WITH FOUR 32K WORD MEMORY BOARDS. UNDER THOSE CIRCUMSTANCES, ; BECAUSE THE RL01/02 CONTROLLER DOES NOT ASSERT THE Q-BUS SIGNAL ; DECLARING AN I/O PAGE ADDRESS TO BE AN I/O PAGE ADDRESS, THE ; MEMORY WILL ANSWER I/O PAGE ADDRESSES. ; .IF NE C$$CDA ;IF RESIDENT CRASH PBNH== 0 ;;;NOT USED PBNL== 2 ;;;RL01/02 CYLINDER,TRACK AND SECTOR .ENDC ; EQ C$$CDA ; ; **** IMPORTANT - PLEASE NOTE **** ; ; WITH LOADABLE CRASH DUMP SUPPORT, PBNL AND PBNH ARE DEFINED WITH ; GLOBAL DEFINITIONS IN THE BUILD FILE FOR EACH DRIVER. ANY ; MODIFICATIONS MADE HERE TO PBNL OR PBNH MUST BE ALSO MADE IN THE ; CORRESPONDING BUILD FILE. ; .IF DF H$$GEN .IF DF, L$$CDA ; GL003 DLDU: INCB CRDEV ; GL003 CMPB #'L,@CRDEV ;;;IS THIS THE RL11? .IFF ; DF L$$CDA DLDU: CMPB #'L,$CRDEV+1 ;;;IS THIS THE RL11? .ENDC ; DF L$$CDA BEQ RL11 ;;;IF EQ YES ;;;ONLY DL/DU FOR P$$GEN SYSTEMS JMP MSCPDV ;;;GO TO MSCP CRASH ROUTINE .ENDC RL11: CALL CKSUM ;;;CHECKSUM DISK ADDRESS .IF DF, L$$CDA ; GL003 CLR @CRBAE ;;;INITIALIZE BAE FLAG ; GL003 .IFF ; DF L$$CDA ; GL003 CLR @#$CRBAE .ENDC ; DF L$$CDA ; GL003 BIS #60,(R0) ;;;SET EXTENDED ADDRESS BITS CLR 10(R0) ;;;CLEAR RLBAE BITS BCS 2$ ;;;IF CS RLBAE DOES NOT EXIST BIT #60,(R0) ;;;DID ADDRESS BITS SET BEQ 3$ ;;;IF EQ YES .IF DF, L$$CDA ; GL003 2$: COM @CRBAE ;;;NO, RESET BAE FLAG ; GL003 .IFF ; DF L$$CDA ; GL003 2$: COM @#$CRBAE ;;;NO, RESET BAE FLAG .ENDC ; DF L$$CDA ; GL003 CLR @#UBMPR ;;;AND INITIALIZE FIRST UNIBUS ... CLR @#UBMPR+2 ;;;;... MAPPING REGISTERS 3$: BIS #60,@#SR3 ;;;ENABLE 22 BIT MAPPING AND UNIBUS MAP MOV #<2044.*4>,-(SP) ;;;NUMBER OF BLOCKS IN 2044K WORDS MOV #<4*4>,R5 ;;;NUMBER OF BLOCKS PER 4K WORDS SWAB R3 ;;;MOVE UNIT NUMBER TO HIGH BYTE BIS #4,R3 ;;;SET GET STATUS FUNCTION MOV #13,4(R0) ;;;SET CODES TO CLEAR DRIVER MOV R3,(R0) ;;;EXECUTE THE FUNCTION 10$: BIT #100200,(R0) ;;;READY OR ERROR? BEQ 10$ ;;;IF EQ NEITHER BMI WERRX ;;;IF MINUS I/O ERROR ADD #4,R3 ;;;CONVERT TO READ HEADER FUNCTION .IF DF, L$$CDA ; GL003 MOV @CRSB2,R4 ;;; SAVE STARTING DISK ADDRESS ; GL003 .IFF ; DF L$$CDA ; GL003 MOV @#$CRSBN+2,R4 ;;;SAVE STARTING DISK ADDRESS .ENDC ; DF L$$CDA ; GL003 CLR 2(R0) ;;;SET BUFFER ADDRESS FOR FIRST WRITE 15$: MOV R3,(R0) ;;;READ HEADER 20$: BIT #100200,(R0) ;;;DONE OR ERROR? BEQ 20$ ;;;IF EQ NEITHER BMI WERRX ;;;IF MINUS I/O ERROR MOV 6(R0),R1 ;;;GET HEADER INFORMATION MOV R4,R2 ;;;COPY DESIRED DISK ADDRESS XOR R1,R2 ;;;FORM A DIFFERENCE BIC #77,R2 ;;;IGNORE SECTOR BITS BEQ 40$ ;;;IF EQ NO SEEK REQUIRED MOV R4,R2 ;;;COPY DESIRED DISK ADDRESS BIC #177,R1 ;;;ISOLATE CYLINDER ADDRESS BIC #177,R2 ;;;ISOLATE CYLINDER ADDRESS DESIRED SUB R2,R1 ;;;SUBTRACT DESIRED FROM ACTUAL BHIS 25$ ;;;IF HIS ACTUAL >=DESIRED NEG R1 ;;;ACTUAL < DESIRED, MAKE POS. DIFF. BIS #4,R1 ;;;SET SIGN FOR MOVE TO CENTER OF DISK 25$: INC R1 ;;;SET MARKER BIT BIT #100,R4 ;;;WHICH HEAD DO WE WANT BEQ 30$ ;;;IF EQ IT'S HEAD 0 BIS #20,R1 ;;;SET HEAD 1 30$: MOV R1,4(R0) ;;;LOAD DIFFERENCE WORD SUB #2,R3 ;;;CONVERT TO SEEK FUNCTION MOV R3,(R0) ;;;START THE SEEK 35$: BIT #100200,(R0) ;;;READY OR ERROR? BEQ 35$ ;;;IF EQ NEITHER BMI WERRX ;;;IF MI I/O ERROR 40$: MOV R4,4(R0) ;;;LOAD DESIRED DISK ADDRESS MOV #-256.,6(R0) ;;;LOAD ONE BLOCK WORD COUNT BIC #17,R3 ;;;REMOVE FUNCTION BITS BIS #12,R3 ;;;SET WRITE FUNCTION MOV R3,(R0) ;;;START THE WRITE 45$: BIT #100200,(R0) ;;;ERROR OR READY? BEQ 45$ ;;;IF EQ NEITHER BMI 70$ ;;;IF MI ERROR DEC (SP) ;;;DUMPED MAXIMUM AMOUNT OF MEMORY? BEQ 72$ ;;;IF EQ YES DEC R5 ;;;DECREMENT BLOCK COUNT BNE 60$ ;;;IF NE USE SAME UMR .IF DF, L$$CDA ; GL003 TST @CRBAE ;;;IS THE BAE REGISTER THERE? ; GL003 .IFF ; DF L$$CDA ; GL003 TST @#$CRBAE ;;;IS THE BAE REGISTER THERE? ; GL003 .ENDC ; DF L$$CDA ; GL003 BEQ 50$ ;;;IF EQ YES ADD #<1024.*4*2>,@#UBMPR ;;;NO, POINT UMR TO NEXT 4K OF MEM ADC @#UBMPR+2 ;;;DOUBLE WORD ADD CLR 2(R0) ;;;RESET BUS ADDRESS 50$: MOV #<4*4>,R5 ;;;NUMBER OF BLOCKS PER 4K WORDS 60$: MOV (R0),R3 ;;;GET CSR BIC #^C<1460>,R3 ;;;ISOLATE UNIT AND EX MEM BITS ADD #2,R4 ;;;MOVE TO NEXT SECTOR MOV R4,R1 ;;;COPY DISK ADDRESS BIC #^C<77>,R1 ;;;GET THE SECTOR BITS CMP #50,R1 ;;;OVERRUN COMING? BNE 40$ ;;;IF NE NO BIS #77,R4 ;;;INCREMENT TRACK... INC R4 ;;;...SET SECTOR TO 0 BIS #10,R3 ;;;SET READ HEADER FUNCTION BR 15$ ;;;AND GO AGAIN 70$: BIT #20000,(R0) ;;;NONEXISTENT MEMORY? BEQ WERRX ;;;IF EQ I/O ERROR 72$: TST (SP)+ ;;;CLEAN THE STACK .IF NDF H$$GEN BR $CRSHT ;;;DUMP DONE .IFF JMP $CRSHT ;;;DUMP DONE .IFTF WERRX: TST (SP)+ ;;;CLEAN THE STACK .IFF JMP WERR ;;;GO TO ERROR HANDLER .ENDC .ENDC ; DF CDA$DL!H$$GEN!DL$$CD .IF EQ C$$CDA-10 ; ; DD ; ; THIS ROUTINE DUMPS ALL OF PHYSICAL MEMORY UP TO A LIMIT OF ; 124K WORDS ; PBNH== 0 ;;;NOT USED BY TU58 TAPE CARTRIDGE PBNL== 1 ;;;STARTING BLOCK NUMBER ; THIS CODE INTERFACES WITH A TU58 VIA A DL11 ASYNCHRONOUS INTERFACE CALL CKSUM ;;;CHECKSUM STARTING BLOCK NUMBER MOV #TRP04,@#114 ;;;POSITION NONEXISTENT MEMORY TRAP ;;;CATCHER FOR CPU'S WHERE MEMORY SIZE ;;;REGISTER > SIZE OF MEMORY CLR @#KISAR6 ;;;WANT TO POINT TO PHYSICAL MEMORY MOV #77406,@#KISDR6 ;;;THROUGH APR6 ; INITIALIZE TU58 CLR -(SP) ;;;RESERVE SPACE ON STACK MOV R3,-(SP) ;;;SAVE UNIT NUMBER BIS #1,4(R0) ;;;SEND BREAK MOV #6,R2 ;;;SET TO SEND 6 NULLS 5$: CLRB 6(R0) ;;;SEND A NULL CALL XWAIT ;;; SOB R2,5$ ;;;LOOP CLR 4(R0) ;;;CLEAR BREAK TST 2(R0) ;;;DUMP RECEIVER BUFFER MOVB #4,6(R0) ;;;SEND INIT CALL XWAIT ;;;WAIT MOVB #4,6(R0) ;;;SEND ANOTHER INIT CALL XWAIT ;;;WAIT 10$: TSTB (R0) ;;;RECEIVED A BYTE? BPL 10$ ;;;IF PL NO CMPB #20,2(R0) ;;;RECEIVED A CONTINUE? BNE 35$ ;;;IF NE NO, I/O ERROR ; SEND COMMAND PACKET MOV @#$CRSBN+2,R2 ;;;SAVE STARTING TU58 ADDRESS 15$: MOV #140000,R1 ;;;INITIALIZE POINTER TO FIRST BYTE ;;;MAPPED BY APR6 MOVB #2,6(R0) ;;;SEND COMMAND FLAG CALL XWAIT ;;;WAIT MOVB #12,6(R0) ;;;SEND COMMAND PACKET BYTE COUNT MOV #<12*400+2>,R4 ;;;INITIALIZE COMMAND PACKET CHECKSUM CALL XWAIT ;;;WAIT MOVB #3,6(R0) ;;;SEND WRITE OP CODE CALL XWAIT ;;;WAIT CLRB 6(R0) ;;;SEND A NULL MODIFIER BYTE MOV #3,R5 ;;;UPDATE PACKET CHECKSUM FOR THOSE CALL CKSM ;;;TWO BYTES AND WAIT MOVB (SP),6(R0) ;;;SEND UNIT NUMBER MOV #4,R3 ;;;SET COUNTER TO SEND 4 NULLS ;;;(SWITCHES, LOW BYTE OF SEQUENCE ;;;NUMBER, HIGH BYTE OF SEQUENCE ;;;NUMBER, LOW BYTE OF BYTE COUNT) 20$: CALL XWAIT ;;;WAIT FOR DL11 CLR 6(R0) ;;;SEND A NULL SOB R3,20$ ;;;LOOP MOV (SP),R5 ;;;UPDATE PACKET CHECKSUM FOR FIRST CALL CKSM ;;;FOUR OF THOSE BYTES AND WAIT MOVB #<1024.*2/400>,6(R0) ;;;SEND HIGH ORDER BYTE OF ;;;NUMBER OF BYTES TO TRANSFER MOV #<1024.*2>,R5 ;;;UPDATE PACKET CHECKSUM FOR CALL CKSM ;;;TRANSFER BYTE COUNT AND THEN WAIT MOV R2,R3 ;;;COPY TU58 LOGICAL BLOCK NUMBER MOVB R3,6(R0) ;;;SEND LOW ORDER BYTE OF ;;;LOGICAL BLOCK NUMBER SWAB R3 ;;; CALL XWAIT ;;;WAIT FOR DL11 MOVB R3,6(R0) ;;;SEND HIGH ORDER BYTE OF ;;;LOGICAL BLOCK NUMBER MOV R2,R5 ;;;UPDATE PACKET CHECKSUM FOR CALL CKSM ;;;LOGICAL BLOCK NUMBER AND WAIT MOVB R4,6(R0) ;;;SEND LOW ORDER BYTE OF CHECKSUM SWAB R4 ;;; CALL XWAIT ;;;WAIT FOR DL11 MOVB R4,6(R0) ;;;SEND HIGH ORDER BYTE OF CHECKSUM ; SEND PROMISED DATA TO TU58 IN 128 BYTE PACKETS MOV #<1024.*2/128.>,2(SP) ;;;NUMBER OF 128 BYTE PACKETS ;;;PER 1K WORDS OF MEMORY 30$: TSTB (R0) ;;;RECEIVED A CHARACTER? BPL 30$ ;;;IF PL NO CMPB #20,2(R0) ;;;RECEIVED A CONTINUE? 35$: BNE DEND ;;;IF NE NO, I/O ERROR MOV #<128./2>,R3 ;;;NUMBER OF WORDS PER PACKET CALL XWAIT ;;;WAIT FOR DL11 MOVB #1,6(R0) ;;;SEND DATA PACKET COMMAND FLAG CALL XWAIT ;;;WAIT FOR DL11 MOVB #128.,6(R0) ;;;SEND NUMBER OF DATA BYTES PER ;;;DATA PACKET MOV #<128.*400+1>,R4 ;;;INITIALIZE DATA PACKET CHECKSUM CALL XWAIT ;;;WAIT FOR DL11 40$: MOV (R1),R5 ;;;WILL USE DATA WORD IN CHECKSUM MOVB (R1)+,6(R0) ;;;SEND FIRST BYTE OF DATA WORD CALL XWAIT ;;;WAIT FOR DL11 MOVB (R1)+,6(R0) ;;;SEND SECOND BYTE CALL CKSM ;;;FACTOR DATA WORD INTO CHECKSUM ;;;AND THEN WAIT SOB R3,40$ ;;;LOOP FOR EACH DATA WORD OF PACKET MOVB R4,6(R0) ;;;SEND LOW ORDER BYTE OF CHECKSUM SWAB R4 ;;; CALL XWAIT ;;;WAIT FOR DL11 MOVB R4,6(R0) ;;;SEND HIGH ORDER BYTE OF CHECKSUM DEC 2(SP) ;;;DECREMENT PACKET COUNT BNE 30$ ;;;IF NE SEND ANOTHER PACKET ; CLEAR OUT END PACKET MESSAGE FROM TU58 MOV #14.,R3 ;;;NUMBER OF BYTES IN AN END PACKET 50$: TSTB (R0) ;;;RECEIVED A CHARACTER? BPL 50$ ;;;IF PL NO TST 2(R0) ;;;DUMP CHARARACTER SOB R3,50$ ;;;LOOP CMP #<7600-40>,@#KISAR6 ;;;HAVE SENT 124K WORDS? BNE 70$ ;;;IF NE NO 60$: CMP (SP)+,(SP)+ ;;;CLEAN OFF STACK BR $CRSHT ;;;SUCCESS 70$: TST (R1) ;;;DOES NEXT MEMORY LOCATION EXIST? BCS 60$ ;;;IF CS NO (NONEXISTENT MEMORY ;;;TRAP CATCHER CAUGHT REFERENCE) ADD #4,R2 ;;;UPDATE TU58 LOGICAL BLOCK NUMBER ADD #40,@#KISAR6 ;;;POINT AT NEXT 1K WORDS OF ;;;PHYSICAL MEMORY JMP 15$ ;;;REPEAT 1K WORD TRANSFER CKSM: ADD R5,R4 ;;;ADD 2ND WORD TO FIRST WITH ADC R4 ;;;END AROUND TREATMENT OF C-BIT XWAIT: TSTB 4(R0) ;;;DL11 TRANSMIT READY? BPL XWAIT ;;;IF PL NO RETURN ;;; DEND: CMP (SP)+,(SP)+ ;;;RESTORE STACK .ENDC .IIF EQ, C$$CDA-12 CDA$MS=0 .IF DF CDA$MS!MS$$CD ;LOADABLE OR RESIDENT CRASH DRIVER ; ; MS ; ; IF THE EXECUTIVE DOES NOT SUPPORT 22-BIT ADDRESSING, THIS ; ROUTINE DUMPS ALL OF PHYSICAL MEMORY (UP TO A MAXIMUM OF ; 124K WORDS) IN 512 BYTE BLOCKS AT 1600 BPI. ; ; IF THE EXECUTIVE SUPPORTS 22-BIT ADDRESSING, THIS ROUTINE ; DUMPS ALL OF PHYSICAL MEMORY IN 512 BYTE BLOCKS AT 1600 BPI. ; .IF NE C$$CDA ;IF RESIDENT CRASH PBNH== 0 ;;;BLOCK NUMBER IGNORED FOR TS11 PBNL== 0 ;;; .ENDC ; EQ C$$CDA ; ; **** IMPORTANT - PLEASE NOTE **** ; ; WITH LOADABLE CRASH DUMP SUPPORT, PBNL AND PBNH ARE DEFINED WITH ; GLOBAL DEFINITIONS IN THE BUILD FILE FOR EACH DRIVER. ANY ; MODIFICATIONS MADE HERE TO PBNL OR PBNH MUST BE ALSO MADE IN THE ; CORRESPONDING BUILD FILE. ; .IF DF, L$$CDA ADD #12,MSCR1 MOV MSCR1,R5 ;;; ADDRESS OF COMMAND PACKET MUST .IFF ; DF L$$CDA ; GL003 MOV #<$MSCR1+12>,R5 ;;; ADDRESS OF COMMAND PACKET MUST .ENDC ; DF L$$CDA ; GL003 BIC #3,R5 ;;;BE ON A DOUBLE WORD BOUNDARY MOV #8.,-(R5) ;;;LENGTH OF COMMAND PACKET IN BYTES CLR -(R5) ;;;UPPER 2 BITS OF COMMAND PACKET ;;;ADDRESS .IF DF, L$$CDA MOV MSCR2,-(R5) ;;; LOW ORDER 16 BITS .IFF ; DF L$$CDA MOV #$MSCR2,-(R5) ;;; LOW ORDER 16 BITS .ENDC ; DF L$$CDA MOV #100004,-(R5) ;;;WANT TO "WRITE CHARACTERISTICS" MOV R5,R4 ;;;COPY POINTER TO COMMAND PACKET. ;;;IF R4.EQ.R5, MS: BEING SET UP. MOV R0,R1 ;;;FORM POINTER TO STATUS REGISTER TST -(R1) ;;; CALL 200$ ;;;ISSUE COMMAND, WAIT FOR SUBSYSTEM, ;;;READY, AND HANDLE ANY ERRORS MOV #142010,(R5) ;;;REWIND AND CLEAR VOLUME CHECK CALL 200$ ;;;ISSUE COMMAND AND WAIT MOV #100005,(R5)+ ;;;WANT TO WRITE MOV #20000,(R5) ;;;ASSUME DATA TRANSFER VIA UMR #1. .IF DF, L$$CDA ; GL003 BIT #HF.UBM,@HFMSK ;;;UMPs ? .IFF ; DF L$$CDA ; GL003 BIT #HF.UBM,@#$HFMSK ;;;UMPs ? .ENDC ; DF L$$CDA ; GL003 BNE 10$ ;;;IF NE, YES. DT TRFR - UMR #1. CLR (R5) ;;;Q BUS - NO UMR'S; START FROM @ 0. 10$: TST (R5)+ ;;;R5 > CMD PKT, 3RD WORD. CLR (R5)+ ;;;CLR HI ORD @ BITS. MOV #512.,(R5) ;;;512 BYTE PER DATA TRANSFER. CLR @#UBMPR+4 ;;;INITIALIZE UMR #1 - CLR @#UBMPR+6 ;;; USED TO MAP DATA TRANSFERS. BIS #60,@#SR3 ;;;ENABLE 22 BIT MAPPING AND UNIBUS MAP. MOV #<2044./4>,R3 ;;;R3 - MAX # OF 4KW BLOCKS. 40$: MOV #<4*4>,R2 ;;;R2 - #512 BYTE RECORDS/4KW MEM BLOCK. 50$: MOV #9.,R5 ;;;RETRY COUNT+1 CALL 200$ ;;;ISSUE WRITE AND WAIT ADD #512.,2(R4) ;;;BUMP START ADDRESS OF DATA ADC 4(R4) ;;; SOB R2,50$ ;;;LOOP UNTIL REACH RECORD LIMIT ;;; (OR UNTIL ERROR IN 200$) ADD #<1024.*4*2>,@#UBMPR+4 ;;;BUMP ADDRESS OF UMR 1 BY ADC @#UBMPR+6 ;;;4K WORDS .IF DF, L$$CDA ; GL003 BIT #HF.UBM,@HFMSK ;;;USING UMR'S? ; GL003 .IFF ; DF L$$CDA ; GL003 BIT #HF.UBM,@#$HFMSK ;;;USING UMR'S? .ENDC ; DF L$$CDA ; GL003 BEQ 60$ ;;;IF EQ, NO. MOV #20000,2(R4) ;;;DT TRF PER UMR #1 @. 60$: DEC R3 ;;;WROTE MAX # 4KW BLOCKS? BNE 40$ ;;;IF NE, NO. ; ; NOTE THAT THE FOLLOWING BRANCH IS NEVER TAKEN IF 180$ IS FALLEN ; INTO (R5 IS NEVER EQUAL TO R4, BECAUSE R5 IS A RETRY COUNT AND ; R4 IS AN ADDRESS, UNLESS 180$ IS BRANCHED TO FROM BELOW) ; 180$: CMP R4,R5 ;;; MS: DEVICE BEING SETUP? BEQ 280$ ;;;IF EQ YES, ERROR EXIT MOV #100011,(R4) ;;;WANT TO FORMAT (WRITE A TAPE ;;;MARK) MOV R4,(R1) ;;;ISSUE COMMAND 190$: TSTB (R0) ;;;SUBSYSTEM READY? BPL 190$ ;;;IF PL NO JMP $CRSHT ;;; SUCCESSFUL TERMINATION 200$: MOV R3,-(SP) ;;;SAVE BLOCK COUNTER 210$: MOV R4,(R1) ;;;ISSUE COMMAND 225$: TSTB (R0) ;;;SUBSYSTEM READY? BPL 225$ ;;;IF PL NO MOV (R0),R3 ;;;GET STATUS BMI 250$ ;;;IF MI ERROR MOV (SP)+,R3 ;;;RESTORE BLOCK COUNTER BIC #1000,(R4) ;;;MAKE SURE "WRITE DATA RETRY" ;;;BIT IS CLEAR RETURN ;;; .IF DF, L$$CDA ; GL003 250$: ADD #6,MSCR3 ; GL003 BIT #1,@MSCR3 ;;;END OF TAPE SEEN? ; GL003 .IFF ; DF L$$CDA ; GL003 250$: BIT #1,@#$MSCR3+6 ;;;END OF TAPE SEEN? .ENDC ; DF L$$CDA ; GL003 BNE 180$ ;;;IF NE YES BIT #4000,R3 ;;;NONEXISTENT MEMORY? BNE 180$ ;;;IF NE YES BIC #^C<16>,R3 ;;;ISOLATE TERMINATION CODE CMP #12,R3 ;;;RECOVERABLE ERROR (TAPE HAS ;;;NOT MOVED)? BEQ 270$ ;;;IF EQ YES CMP #10,R3 ;;;RECOVERABLE ERROR (TAPE HAS ;;;MOVED ONE RECORD)? BNE 280$ ;;;IF NE NO, I/O ERROR BIS #1000,(R4) ;;;CHANGE COMMAND TO "SPACE REVERSE, ;;;ERASE, WRITE DATA" 270$: DEC R5 ;;;EXHAUSTED RETRY COUNT? BNE 210$ ;;;IF NE NO 280$: TST (SP)+ ;;;DISCARD RETURN ADDRESS .ENDC ; DF CDA$MS!MS$$CD .IIF EQ C$$CDA-13 .ERROR C$$CDA ;DX CRASH NOT SUPPORTED .IIF EQ C$$CDA-14 .ERROR C$$CDA ;DY CRASH NOT SUPPORTED .IIF EQ C$$CDA-15 .ERROR C$$CDA ;MF CRASH NOT SUPPORTED .IIF EQ C$$CDA-21 CDA$NT=0 .IF DF CDA$NT!NT$$CD ; ; NT - NETWORK DUMP ; ; THIS ROUTINE DUMPS ALL OF MEMORY OVER THE NETWORK TO A WILLING HOST ; .IF NE C$$CDA ; IF RESIDENT CRASH PBNH== 0 ;;;STARTING BLOCK NUMBER ... PBNL== 1 ;;;... .ENDC ; EQ C$$CDA JMP $PANIC ;;; JUMP TO NETPAN MODULE .ENDC ; CDA$NT!NT$$CD .IIF EQ C$$CDA-16 CDA$DU=0 .IF DF CDA$DU!H$$GEN!DU$$CD ; ; DU ; ; THIS ROUTINE DUMPS ALL OF MEMORY ONTO A REMOVABLE MEDIA MSCP ; TYPE DEVICE. CURRENTLY THE VALID DEVICES ARE RA60, RC25, AND ; RX50. ; .IF NE C$$CDA ;IF RESIDENT CRASH PBNH== 0 ;;;STARTING BLOCK NUMBER ... PBNL== 1 ;;;... .ENDC ; EQ C$$CDA ; ; **** IMPORTANT - PLEASE NOTE **** ; ; WITH LOADABLE CRASH DUMP SUPPORT, PBNL AND PBNH ARE DEFINED WITH ; GLOBAL DEFINITIONS IN THE BUILD FILE FOR EACH DRIVER. ANY ; MODIFICATIONS MADE HERE TO PBNL OR PBNH MUST BE ALSO MADE IN THE ; CORRESPONDING BUILD FILE. ; MSCPDV: CALL CKSUM ;;;CHECKSUM DISK ADDRESS ; ; AT THIS TIME: ; ; R0=CSR ADDRESS ; R3=UNIT NUMBER ; CONTROLLER IS IN AN UNKNOWN STATE ; .IF EQ,C$$CDA ; LOADABLE CRASH CLR RELOC ;;;CLEAR RELOCATION WORDS CLR RELOC+2 .ENDC ; EQ C$$CDA MOV #$DUCSH,R2 ;;;GET ADDRESS OF INTIALIZATION TABLE MOV (R2)+,R4 ;;;GET ADDRESS OF COMMAND PACKET MOV (R2)+,R5 ;;;GET ADDRESS OF RESPONSE PACKET MOVB R3,P.UNIT(R4) ;;;STORE UNIT NUMBER IN COMMAND PACKET CLR R3 ;;;ASSUME EXTENDED MEMORY SUPPORT MOV #4000,R1 ;;;SETUP FOR STEP 1 MOV R1,(R0)+ ;;;INITIALIZE PORT INTERFACE 10$: TST (R0) ;;;ANY CONTROLLER ERRORS? BPL 12$ ;;;IF PL NO JMP WERR ;;;ERROR ROUTINE 12$: BIT R1,(R0) ;;;IS CONTROLLER AT RIGHT STEP? BEQ 10$ ;;;IF EQ NO, WAIT CMP #4000,R1 ;;;DID WE JUST DO STEP 1? BNE 15$ ;;;IF NE NO .IF EQ,C$$CDA ; LOADABLE CRASH ; ; FIGURE RELOCATION WORD: ; - IF 22 BIT ADDRESSING, THEN THE RELOCATION BIAS WILL BE ADDED TO ; THE VIRTUAL ADDRESS TO GIVE A 22 BIT PHYSICAL ADDRESS ; - IF NOT, THE RELOCATION BIAS WILL BE USED AS THE UMR VALUE AND THE ; PHYSICAL ADDRESS WILL BE MAPPED USING UMR 5 ; MOV @KISA5,RELOC ;;;ADDRESS OF CODE ; GL003 .REPT 6 ASL RELOC ;;;CHANGE TO 22 BIT ROL RELOC+2 .ENDR CLR 4(R2) ;;;CLEAR HIGH WORD MOV #RINGS,2(R2) ;;;ADDRESS OF RINGS BIT #1000,(R0) ;;;CONTROLLER SUPPORT EXTENDED MEMORY? BEQ 13$ ;;; EQ, NO - MUST USE UMRS SUB #120000,RELOC ;;;SUBTRACT VIRTUAL 120000 SBC RELOC+2 ;;;TO MAKE ADDR RELOCATION EASIER ADD RELOC,2(R2) ;;;ADD RELOCATION (LOW WORD) ADC 4(R2) ;;;ADD THE CARRY ADD RELOC+2,4(R2) ;;;ADD RELOCATION (HIGH WORD) BR 15$ ;;;BRANCH AROUND UMR SETUP CODE 13$: MOV RELOC,@#UBMPR+24;;;SET UP UMR 5 ; GL003 MOV RELOC+2,@#UBMPR+26 ; GL003 COM R3 ;;;SET UMR FLAG .ENDC ; EQ C$$CDA .IF NE,C$$CDA ; RESIDENT CRASH BIT #1000,(R0) ;;;CONTROLLER SUPPORT EXTENDED MEMORY? BNE 15$ ;;;IF EQ YES COM R3 ;;;NO, SET UMR FLAG .ENDC ; NE C$$CDA 15$: MOV (R2)+,(R0) ;;;SEND STEP WORD TO CONTROLLER ASL R1 ;;;MOVE STEP BIT BPL 10$ ;;;IF PL KEEP STEPING MOV (R2)+,R2 ;;;GET ADDRESS OF RESPONSE RING .IF EQ, C$$CDA ; LOADABLE CRASH TST R3 ;;;EXTENDED MEMORY SUPPORT BNE 17$ ;;;NE, NO - MUST USE UMR'S MOV R5,(R2) ;;;RESET RESPONSE RING ADD RELOC,(R2)+ ;;;ADD RELOCATION (LOW WORD) MOV RELOC+2,(R2) ;;;RELOCATION (HIGH WORD) ADC (R2)+ ;;;ADD THE CARRY MOV R4,(R2) ;;;RESET COMMAND RING ADD RELOC,(R2)+ ;;;ADD RELOCATION (LOW WORD) MOV RELOC+2,(R2) ;;;RELOCATION (HIGH WORD) ADC (R2) ;;;ADD THE CARRY CMP -(R2),-(R2) ;;;DECREMENT 2 WORDS BR 18$ ;;;BRANCH AROUND RESETS .ENDC ; EQ C$$CDA 17$: MOV R5,(R2)+ ;;;RESET RESPONSE RING MOV R4,2(R2) ;;;RESET COMMAND RING 18$: CALL RSET ;;;RESET OWNERSHIP WORDS IN RING ; ; CONTROLLER IS NOW INITIALIZED ; NEXT, PUT CONTROLLER AND UNIT ONLINE ; ; R0=CSR ADDRESS +2 ; R1=100000 ("OWN") ; R2=ADDRESS OF SECOND WORD OF RESPONSE RING ; R3=EXTENDED MEMORY FLAG ; R4=COMMAND PACKET ADDRESS ; R5=RESPONSE PACKET ADDRESS ; MOVB #OP.ONL,P.OPCD(R4) ;;;LOAD ONLINE FUNCTION CODE CLR P.BCNT(R4) ;;;NO WORD COUNT NEEDED CALL IO ;;;DO THE ONLINE FUNCTION MOVB #OP.GUS,P.OPCD(R4) ;;;LOAD GET UNIT STATUS FUNCTION CALL IO ;;;DO THE GET STATUS BIT #UF.RMV,P.UNFL(R5) ;;;IS THIS A REMOVEABLE MEDIA UNIT? BNE 20$ ;;;IF NE YES .IF DF, L$$CDA ;;; LOADABLE CRASH MOV CRMS6,R1 ;;; ILLEGAL DEVICE .IFF ; DF L$$CDA MOV #$CRMS6,R1 ;;;ILLEGAL DEVICE .ENDC ; DF L$$CDA BR WERR1 ;;;PRINT MESSAGE AND TRY AGAIN 20$: MOVB #OP.WR,P.OPCD(R4) ;;;LOAD WRITE DATA FUNCTION CODE MOV #<512.*4*4>,P.BCNT(R4) ;;;BYTE COUNT FOR 4KW .IF DF, L$$CDA ;;; LOADABLE CRASH MOV @CRSB2,P.LBN(R4) ;;; SET STARTING LBN MOV @CRSBN,P.LBN+2(R4) ;;; ... .IFF ; DF L$$CDA MOV @#$CRSBN+2,P.LBN(R4) ;;; SET STARTING LBN MOV @#$CRSBN,P.LBN+2(R4) ;;; ... .ENDC ; DF L$$CDA CLR P.BUFF(R4) ;;;START AT PHYSICAL 0 CLR P.BUFF+2(R4) ;;;... CLR R1 ;;;Init counter for every 4KW written BIS #60,@#SR3 ;;;ENABLE 22-BIT AND UMRS TST R3 ;;;EXTENDED ADDRESSING SUPPORTED? BEQ 30$ ;;;IF EQ YES CLR @#UBMPR+4 ;;;NO, USE UMRS CLR @#UBMPR+6 ;;;... MOV #20000,P.BUFF(R4) ;;;SET BUFFER ADDRESS THRU UMR 1 ; ; ALL INITIAL VALUES ARE SETUP. NOW TRANSFER THE DATA. ; 30$: CALL IO ;;;WRITE 4KW TO DISK INC R1 ;;; # of 4KW count <== count + 1 CMP #511.,R1 ;;; Wrote MAX memory (511.*4KW = 2044KW) ? BEQ $CRSHT ;;; If EQ, yes all done ADD #<4*4>,P.LBN(R4);;;MOVE TO NEXT STARTING LBN ADC P.LBN+2(R4) ;;;... TST R3 ;;;EXTENDED MEMORY SUPPORTED? BEQ 40$ ;;;IF EQ YES ADD P.BCNT(R4),@#UBMPR+4 ;;;UPDATE UMR ADDRESS ADC @#UBMPR+6 ;;;... BR 30$ ;;;KEEP WRITING 40$: ADD P.BCNT(R4),P.BUFF(R4) ;;;UPDATE BUFFER ADDRESS ADC P.BUFF+2(R4) ;;;... BR 30$ ;;; ; ; DO THE I/O AND CHECK FOR ERRORS. THE ONLY VALID ERRORS ARE ; NON-EXISTANT MEMORY AND INVALID COMMAND. ; .ENABL LSB IO: TST -2(R0) ;;;FORCE CONTROLLER TO LOOK AT RINGS 10$: TST (R0) ;;;CONTROLLER STILL ONLINE? BMI 20$ ;;;IF MI, NO. TST (R2) ;;;CONTROLLER SEND BACK A RESPONSE? BMI 10$ ;;;IF MI NO, IT STILL "OWNS" THE PACKET TST P.STS(R5) ;;;ANY ERRORS? BNE 20$ ;;;IF NE YES RSET: BIS #100000,(R2) ;;;SET OWN FLAG INTO RINGS BIS #100000,4(R2) ;;;... RETURN ;;; 20$: TST (SP)+ ;;;CLEANUP STACK CMP #ST.NXM,P.STS(R5) ;;;NON-EXISTANT MEMORY? BEQ $CRSHT ;;;IF EQ YES, ALL DONE CMPB #ST.CMD,P.STS(R5) ;;;DID WE OVERRUN THE DISK? BEQ $CRSHT ;;;IF EQ YES, ALL DONE ;;;NO, FATAL ERROR, FALL THRU .DSABL LSB .ENDC ; DF CDA$DU!H$$GEN!DU$$CD .PAGE .IIF EQ, C$$CDA-17 CDA$MU=0 .IF DF CDA$MU!MU$$CD ;LOADABLE OR RESIDENT CRASH DRIVER ; ; MU ; ; IF 22-BIT ADDRESSING IS NOT SUPPORTED, THEN THIS ROUTINE DUMPS ALL ; OF PHYSICAL MEMORY (TO A MAX OF 124K WORDS) IN 512 BYTE BLOCKS. ; ; IF 22-BIT ADDRESSING IS SUPPORTED, THEN THIS ROUTINE DUMPS ; ALL OF PHYSICAL MEMORY IN 512 BYTE BLOCKS. ; .IF NE C$$CDA ;IF RESIDENT CRASH PBNH== 0 ;;;BLOCK NUMBER IGNORED FOR MU: DEVICE PBNL== 0 ;;; .ENDC ; NE C$$CDA ; RESTRICTION: ; ; WITH LOADABLE CRASH DUMP SUPPORT, PBNL .AND. PBNH ARE DEFINED ; WITH GLOBAL DEFINITIONS IN THE BUILD FILE FOR EACH DRIVER. ; ; ANY MODIFICATIONS MADE HERE TO PBNL OR PBNH MUST BE ALSO MADE ; IN THE CORRESPONDING BUILD FILE. ; ; R0 - CSR, R3 = UNIT NUMBER, CNTRL IN AN UNKNOWN STATE .IF EQ C$$CDA ; LOADABLE CRASH CLR RELOC ;;; Clear relocation words CLR RELOC+2 .ENDC ; EQ C$$CDA MOV #$MUCSH,R2 ;;; R2 > MU: Initialization table MOV (R2)+,R4 ;;; R4 > Command packet MOV (R2)+,R5 ;;; R5 > Response packet MOVB R3,P.UNIT(R4) ;;; Command packet <-- Unit number CLR R3 ;;; R3 - IF EQ, THEN 22 bit @. MOV #4000,R1 ;;; R1 - setup for Step 1. MOV R1,(R0)+ ;;; Initialize the MU: controller 10$: TST (R0) ;;; Controller errors? BPL 12$ ;;; IF PL, No. JMP WERR ;;; Else - indicate error. 12$: BIT R1,(R0) ;;; Controller at correct step? BEQ 10$ ;;; IF EQ, No - Wait for it. CMP #4000,R1 ;;; Just complete Step 1? BNE 15$ ;;; IF NE, No. .PAGE .IF EQ C$$CDA ; LOADABLE CRASH ; Setup relocation words: ; ; If 22 bit @, THEN the relocation bias will be added to the ; virtual @ to give a 22 bit physical @. ; ; If not, THEN the relocation bias will be used as the UMR value ; and the physical @ will be mapped using UMR 5. MOV @KISA5,RELOC ;;; > MU: crash code. ; GL003 .REPT 6 ASL RELOC ;;; Convert to ROL RELOC+2 ;;; 22 bit @. .ENDR CLR 4(R2) ;;; Clear high (@) word MOV #RINGS,2(R2) ;;; and setup Rings @. BIT #1000,(R0) ;;; MU: controller in 22 bit @ mode? BEQ 13$ ;;; IF EQ, NO - use UMRS. ; Setup 22 bit RING @. SUB #120000,RELOC ;;; Subtract APR #5 SBC RELOC+2 ;;; virtual @ (120000). ADD RELOC,2(R2) ;;; RELOC,+2 > physical ADC 4(R2) ;;; 22 bit @ ADD RELOC+2,4(R2) ;;; of Rings. BR 15$ ;;; 22 bit @ of Rings setup. ; Setup Rings @ via UMR #5. 13$: MOV RELOC,@#UBMPR+24 ;;; Use UMR #5 MOV RELOC+2,@#UBMPR+26 ;;; for Rings @. COM R3 ;;; R3 - IF NEQ, THEN using UMRs. .ENDC ; EQ C$$CDA .IF NE,C$$CDA ; RESIDENT CRASH BIT #1000,(R0) ;;; MU: controller in 22 bit @ mode? BNE 15$ ;;; IF NEQ, No. COM R3 ;;; R3 - IF NEQ, THEN using UMRs. .ENDC ; NE C$$CDA 15$: MOV (R2)+,(R0) ;;; Next Init step word to controller. ASL R1 ;;; Prepare for next Init phase. BPL 10$ ;;; IF PL, more Init phases. MOV (R2)+,R2 ;;; R2 > Response ring. .PAGE .IF EQ C$$CDA ; LOADABLE CRASH TST R3 ;;; 22 bit @ mode? BNE 17$ ;;; IF NE, No - use UMRs. ; 22 bit @ mode MOV R5,(R2) ;;; Update ADD RELOC,(R2)+ ;;; > to MOV RELOC+2,(R2) ;;; Response ADC (R2)+ ;;; ring. MOV R4,(R2) ;;; Update ADD RELOC,(R2)+ ;;; > to MOV RELOC+2,(R2) ;;; Command ADC (R2) ;;; ring. CMP -(R2),-(R2) ;;; R2 > RSP+2 BR 18$ ;;; and cont. .ENDC ; EQ C$$CDA ; Use UMRs 17$: MOV R5,(R2)+ ;;; Update > to Response ring. MOV R4,2(R2) ;;; Update > to Response ring. 18$: CALL RSET ;;; Controller owns rings. MOV #401,-2(R4) ;;; Setup virt ckt/credit. ; Controller initialized - put controller and unit online ; ; R0 > Device SA register (CSR+2) ; R1 = 100000 ("OWN" mask) ; R2 > RSP+2 ; R3 IF EQ - 22 BIT @, ELSE NE - UMRs. ; R4 > Command packet R5 > Response packet ; ; Clear the command packet fields. MOV R4,R1 ;;; R1 > Command packet area. MOV -4(R4),-(SP) ;;; Stack has size of CMD PKT area. 117$: CLR (R1)+ ;;; Clear CMD PKT area. SUB #2,(SP) ;;; At the end of CMD PKT area? BNE 117$ ;;; IF NE, No - keep clearing. TST (SP)+ ;;; Maintain the stack. ; Setup controller characteristics. MOVB #OP.SCC,P.OPCD(R4) ;;; Setup CONTROLLER characteristics MOV #0,P.CNTF(R4) ;;; for no extraneous messages. CALL IO ;;; Issue request. ; ONLINE the controller. MOVB #OP.ONL,P.OPCD(R4) ;;; Setup ONLINE CLR P.BCNT(R4) ;;; function code. CALL IO ;;; Issue request. ;Rewind the unit MOVB #OP.REP,P.OPCD(R4) ;;; Setup to Reposition - MOV #MD.CSE!MD.RWD,P.MOD(R4) ;;; Rewind to BOT. CALL IO ;;; Issue request. ; Write 512. byte memory areas to tape. MOVB #OP.WR,P.OPCD(R4) ;;; Setup WRITE DATA function code, MOV #512.,P.BCNT(R4) ;;; 512. byte count and MOV #MD.CSE,P.MOD(R4) ;;; no serious exceptions. CLR (R4) ;;; CMD Ref <-- 0. CLR P.BUFF(R4) ;;; Assume 22 bit @ and CLR P.BUFF+2(R4) ;;; start at physical 0. BIS #60,@#SR3 ;;; Enable 22-bit @ mode and UMRS. TST R3 ;;; 22 bit @ mode? BEQ 20$ ;;; IF EQ, Yes. CLR @#UBMPR+4 ;;; Initialize UMR #1 - CLR @#UBMPR+6 ;;; used to map data transfers. 19$: MOV #20000,P.BUFF(R4) ;;; Data transfer per UMR #1 @. 20$: MOV #<4*4>,R1 ;;; R1-#512 byte records/4KW mem block. 25$: INC (R4) ;;; CMD Ref <-- +1. ; Cmd PKT setup - write 512. byte record. 30$: CALL IO ;;; Write 512. byte record. CMP #<2044.*4>,(R4) ;;; Wrote max allowed memory ? BEQ WTMK ;;; If EQ yes, write TMK, & done ADD #512.,P.BUFF(R4) ;;; > next 512. ADC P.BUFF+2(R4) ;;; byte of memory. SOB R1,25$ ;;; Keep writing until 4KW boundary. TST R3 ;;; 22 bit @ mode? BEQ 20$ ;;; IF EQ, Yes. ADD #<1024.*4*2>,@#UBMPR+4 ;;; Increment UMR #1 ADC @#UBMPR+6 ;;; by 4KW. BR 19$ ;;; Write next 4KW memory block. ; Start I/O and check for errors - only valid error is non-existing mem. ; All other errors are unrecoverable. .ENABL LSB IO: MOV #60,-4(R5) ;;; Response packet - max lenght. TST -2(R0) ;;; Start I/O - Controller polls rings. 10$: TST (R0) ;;; Controller yet ONLINE? BPL 15$ ;;; IF PL, OK. TST (SP)+ ;;; Else - maintain stack, MOV #SAMSG,R1 ;;; R1 > SA error message BR WERR1 ;;; and issue it. 15$: TST (R2) ;;; Controller yet own RSP ring? BMI 10$ ;;; IF MI, Yes. MOV P.STS(R5),-(SP) ;;; Isolate BIC #^C<37>,(SP) ;;; end code. TST (SP)+ ;;; Success? BNE 20$ ;;; IF NE, No -error, can't handle it. RSET: BIS #100000,(R2) ;;; Controller 'OWNS' BIS #100000,4(R2) ;;; the rings. RETURN 20$: TST (SP)+ ;;; Maintain stack. CMP #ST.NXM,P.STS(R5) ;;; Non-existing memory? BEQ WTMK ;;; IF EQ, Yes - write TMK and end. CMP #ST.HST,P.STS(R5) ;;; Max allowed memory? BEQ WTMK ;;; IF EQ, Yes - write TMK and end. MOV #PSTMSG,R1 ;;; Else - R1 > P.STS error message. ; Write a TMK and complete Crash to MU: device. WTMK: CMPB #OP.WTM,P.OPCD(R4) ;;; Already tried to WTMK? BEQ WERR1 ;;; IF EQ, Yes - then end crash. MOVB #OP.WTM,P.OPCD(R4) ;;; Write a TMK and MOV #MD.CSE,P.MOD(R4) ;;; no serious exceptions. CALL RSET ;;; Controller owns the rings. CALL IO ;;; Issue request. CMP #PSTMSG,R1 ;;; Had a P.STS error? BEQ WERR1 ;;; IF EQ, Yes - then end crash. BR $CRSHT ;;; All done. .DSABL LSB .ENDC ; DF CDA$MU!MU$$CD .PAGE .IFT ; DF L$$CDA!R$CRSH ;+ ; WHEN AN ERROR IS DETECTED BY A CRASH ROUTINE, CONTROL IS TRANSFERED ; HERE EITHER BY A JUMP, BR, OR BY SIMPLY FALLING THRU TO THIS SIMPLE ; ERROR HANDLER. ;- .IF DF, L$$CDA WERR: MOV CRMS3,R1 ;;; INDICATE I/O ERROR .IFF ; DF L$$CDA WERR: MOV #$CRMS3,R1 ;;;INDICATE I/O ERROR .ENDC ; DF L$$CDA WERR1: CALL TYPE ;;;TYPE OUT MESSAGE JMP AGAIN ;;;WAIT FOR THE USER ;+ ; AFTER THE DUMP HAS SUCCESSFULLY COMPLETED, THE CRASH ROUTINE SHOULD ; BRANCH TO HERE SO THAT THE PROCESSOR MAY BE HALTED AND ANOTHER DUMP ; BE TAKEN. ;- $CRSHT: HALT ;;;WAIT FOR USER .IF DF L$$CDA JMP @CRALT .IFF ;DF L$$CDA JMP @#$CRALT .ENDC ;DF L$$CDA .PAGE .IF DF DU$$CD!MU$$CD ; DU/MU CRASH DRIVER ; CRASH DATA BASE FOR DU/MU DEVICES ; RESTRICTION - any changes to this table must ALSO BE MADE IN LOWCR.MAC. ; For Resident crash - this is in exec CRASH module area ; and for loadable CRASH, it's in the DU/MU crash area. ; COMMAND AND RESPONSE PACKETS .WORD 60 ; Packet length - 48. .WORD 1 ; Virtual circuit and credit/debit field. CMDPKT: .WORD 1 ; Command packet area. .REPT 23. .WORD 0 ; initially - 0s. .ENDR .BLKW 2 ; Envelope. RSPPKT: .BLKW 24. ; Response packet area. ; COMMAND RINGS .BLKW 2 RINGS: RSP: .WORD RSPPKT ; Response packet ring - .WORD 100000 ; Packet "owned" by controller. CMD: .WORD CMDPKT ; Command packet ring - .WORD 100000 ; Packet "owned" by controller. ; INITIALIZATION TABLE $DUCSH:: $MUCSH::.WORD CMDPKT ; > CMD packet. .WORD RSPPKT ; > RSP packet. .WORD 100000 ; STEP 1 - lenght of rings,IE,Int vec/4. .WORD RINGS ; 2 - lo ord .WORD 0 ; 3 - and hi ord @ of Rings. .WORD 1 ; 4. .WORD RSP ; > Response ring RELOC: .WORD 0,0 ;RELOCATION WORDS .ENDC ; DF DU$$CD!MU$$CD .IF DF CDA$MU!MU$$CD ; MU CRASH DRIVER P.NDCD = P.OPCD .NLIST BEX SAMSG: .ASCIZ <15><12><12>!CRASH -- I/O [SA] DEVICE ERROR;! PSTMSG: .ASCIZ <15><12><12>!CRASH -- I/O (P.STS) DEVICE ERROR;! .LIST BEX .ENDC ; DF CDA$MU!MU$$CD .PAGE .IF DF H$$GEN .IIF EQ C$$CDA-7, PBNL==2 ;DEFAULT TO RL11 .ENDC .ENDC ; DF L$$CDA!R$CRSH .ENDC ; EQ C$$CDA-20 .ENDC ;C$$CDA .END